Armen Zambrano: Mozilla CI tools: Upcoming support for Buildbot Bridge |
|
|
Air Mozilla: Webmaker Demos Sept 18 2015 |
Webmaker Demos Friday Sept 18 2015 https://webmaker.etherpad.mozilla.org/demos
|
|
Mike Hoye: Catching A Moving Train |
I made a joke the other day on the twitters that I was writing a job req, how I needed a way to say “Experience surfing on top of a relentless, multichannel, broad-spectrum communications avalanche a major plus”. That didn’t go over fantastically well with HR, believe you me, but it’s a real part of life here; the price of openness and transparency worth paying, steep as it is some days.
When I started at Mozilla, onboarding wasn’t really a thing. Getting started wasn’t quite “here’s your desk, here’s your password and here’s your job”, but it wasn’t a lot more than that, and there were some things we either overlooked or got wrong that made it hard to be effective for a long time. As one example – my personal favourite – I was signed up for all the mailing lists I’d need to do my job two weeks before I actually started; so thirty minutes into my first day on the new job I was two weeks behind on my email.
As of now we’re going to start doing that better, a lot better, and we’re trying to do it the way we aspire to do everything: up front and open, with no special magic or secret sauce, where people can watch us succeed or fail, and learn and grow from either one. Over the next two weeks, we’re going to be bringing in a new hire and running daily sessions to help them ramp up on the tools, technologies, processes and skills they need to be effective as a Mozilla engineer, including sessions on:
These sessions will be open to attend; not just for Mozilla’s engineers, but to any community member and contributor who wishes. This is the schedule of events; we also have a streaming video link that will go live on the day of (Flash required, sadly). We’ll be documenting the process and collecting it into a single place for consumption shortly afterwards.
I’m charged with Comms & Community, so that’s just me and whatever, but myself aside the list of participants for this thing is remarkable. I don’t know if I can be specific right this second – This List Is Subject To Change Without Notice, and so on – but there is some powerhouse engineering talent running the rest of those sessions. And if you want to be a part of that, you can. If you want to sit in, learn about some part of this organization and engines it drives, you’re invited.
We’ll be reviewing the whole process as it unfolds – what works, what doesn’t, what we can learn from it – and reviewing it weeks and months later, to evaluate success, see what we’ve learned, what we’ve missed, and how we can improve. If you have feedback, send it my way; we know we have to get a lot better at this fast, and the best way we know how to do that is together.
http://exple.tive.org/blarg/2015/09/18/catching-a-moving-train/
|
|
Ahmed Nefzaoui: Why Right-To-Left is even more important for feature phones |
It’s publicly knowledgeable right now that at Mozilla we’re working on allowing even people with no little to no technical knowledge to have access to the Internet’s content through making what we call Smart Feature Phones that work with Firefox OS, those flip flop phones and ones with possibly no touch screens, added to them smart features that are still suitable for the audience and the users of such devices.
http://nefzaoui.tn/blog/2015/09/why-right-to-left-is-even-more-important-for-feature-phones/
|
|
Adam Lofting: Software as means of changing the world |
This is a thought piece as part of the Mozilla Learning strategy project. In particular it’s a contribution to the Advocacy Working Group who are looking at how we design a programme to have impact at a significant global scale as one part of an organisational mission to create Universal Web Literacy.
To be clear, this is an input into the strategy project, not an output. This may or may not be something Mozilla Learning chooses for it’s strategy, but I put my name down to write this piece as it’s something I’ve been thinking about.
I agreed to write ‘a paragraph or two’. It turns out I have more thoughts on this.
Point 1. We could choose to build software as a deliberate means of creating change
Mozilla is known for changing the world by building software. We have precedent for taking this approach and exceptionally talented engineers around the world want to play a part in this story (both as staff and volunteers). Building new software products is hard, but if successful can scale to have a disproportionate impact in relation to investment.
Point 2. We can create change via software without writing any code
Through partnership with existing consumer software products, we could deliver web literacy content/training/engagement independently of any software we build. This approach can also have a disproportionate impact to investment return. Can we be there to greet the next billion as they come online and create their first accounts / profiles / digital identities? What would that look like? Is that something we want to work on?
Both approaches are valid options for a strategy, but require very different execution. They are not mutually exclusive.
This rest of this isn’t entirely coherent, but I can’t spend longer on it right now…
I’m going to argue that choosing software as a method for creating deliberate change in the world is potentially the most cost effective route to large scale impact.
I’ve been thinking about this topic for a while, and want to start by directing you to a short post I wrote three years ago – Interwoven with bits – it distills a topic I could write about for days on end. We shape software, and software shapes us.
The software that changes the world takes many forms. A list of examples could technically include all software that continues to be used by any human being (directly and indirectly). But I’ll call out a few categories:
In general, when I’m thinking about how software changes the world, I’m thinking about how the mass adoption of a piece of software creates a shift in behavioural norms. The more successful and/or popular a piece of software is, the more likely it is to have more impact on the world.
For people who want to fix the world with software, it’s easy to look at ‘Silicon Valley’ success stories and get excited about building the next big thing. But in a sensible planning process these inspiring stories need the context of survivor bias.
Most software will go to market and die. The same is true of most inventions and artistic creations. The majority who try to build something and ‘fail’ are known as the “optimistic martyrs“. Most software dies in the market because the formula for winning is elusive, and even a well defined target market is actually a collection of complex busy human beings.
People who build software with purely good intentions about making the world a better place face an even bigger challenge – they don’t have the forcing function of the market to keep them focused. That’s not to say it can’t be done (see Firefox), but as someone who uses numbers to influence decision making, numbers with currency symbols next to them always get a more direct response.
As an advocacy strategy, choosing software as a means of changing the world would be a gamble. Even with the best people working on it.
But software is interesting because of its relatively low cost of development and distribution. These costs don’t need to scale with success – they become negligible if a product reaches a mass consumer market. I.e. the cost to impact an extra person beyond a critical mass approaches zero.
Therefore, the potential ROI on software is enormous (thanks Internet!). But potential is a word that optimistically wraps up unknown odds.
There’s a good reason that successful start-ups that scale are called ‘unicorns’.
At this point I want to reflect on a Mozilla bias.
I was drawn into the org through experiencing this bias at my first Mozfest – hacking on software in my free time as a way to try and change the world.
Many people work at Mozilla because they believe building great software makes the world a better place; myself included. This is Mozilla’s heritage and origin story. But it might not always be the best or only solution to a given problem.
This next piece is not to exclude the option of building software. But I’d like to approach this section as though Mozilla didn’t have its history of building products and as though it was a new org setting out to advocate for Universal Web Literacy using software as a means of creating change.
If you pick a particular goal, like helping the next billion new users of the internet who come online in a mobile-first capacity to understand the full scope of the web, what is the most effective route to success?
We’ve already been exploring how to build learning opportunities into Firefox, but what about partnering with the organisations who own many other front doors to ‘the web’. For example, if you create a Twitter/WhatsApp/Telegram/Other account in Bangladesh, can we work with owners of those products to offer a locally relevant and meaningful crash course to the web – covering everything from privacy to economic opportunity? Something that delivers on our mission, but also adds real value to the end-user and the product owner. How much effort would be required to make that happen? How many people could we reach?
Though I noted the example of the WWF Rhino Raid game in the list above, many well intentioned orgs have tried to create software like apps and games as a way to change the world without understanding the real nuances of product (games are possibly the hardest to get right). As an example of using the partnership approach, WWF have also run campaigns in existing successful consumer products via partnerships, like these in game experiences.
When I talked about this concept briefly on our last working group call, Laura flagged up that Tumblr directs users who explore their theme editor to online training courses run by General Assembly. This is the kind of partnership that adds value in both directions. Tumblr want users to build higher quality sites, and General Assembly want to educate people who have an active interest in learning about these topics.
After thinking through the points above, I’d advocate for ‘advocating’ with software; some of which we build, some of which we don’t.
The potential investment to impact ratio for a software product that scales is immense. But it requires a long-term product strategy.
I’d argue that good products typically last longer than good campaigns, and my view is that the most meaningful change comes from what we help people do repeatedly.
Software also offers a degree of measurability and accountability hard to match in any other line of work. If I were an impact investor, that’s where I’d put my money, for that reason. Though I definitely have a bias here.
This isn’t to say what software we should build.
http://feedproxy.google.com/~r/adamlofting/blog/~3/Ps7sEZntDp0/
|
|
Daniel Stenberg: daniel weekly 41, now in markdown |
Episode 41, just out:
http2 explained in markdown, translations. Swedish?
curl feature freeze period, release october 7
Bug of the week: Downloading a long sequence of URLs results in high CPU usage and slowness
Option of the week: -O
http://daniel.haxx.se/blog/2015/09/18/daniel-weekly-41-now-in-markdown/
|
|
Vaibhav Agrawal: Mozilla Internship Ends |
I have been inconsistent in blogging about the projects I have been working on, in this internship. If you would like to know about the projects I worked on in this internship, I have done a presentation archived on Air Mozilla: https://air.mozilla.org/vaibhav_agrawal/
Today is the last day of my internship. This internship has been a fun and enriching experience. I got to meet some amazing people, work on impactful projects and explore interesting places in San Francisco. I would like to thank all the people who made it happen and who helped me throughout this journey. Thanks and so long!
https://vaibhavag.wordpress.com/2015/09/18/mozilla-internship-ends/
|
|
Mark Finkle: Is Ad Blocking Really About The Ads? |
Since Apple released iOS9 with Content Blocking extensions for Safari, there has been a lot of discussion about the ramifications. On one side, you have the content providers who earn a living by monetizing the content they generate. On the other side, you have consumers who view the content on our devices, trying to focus on the wonderful content and avoid those annoying advertisements.
But wait, is it really the ads? The web has had advertisements for a long time. Over the years, the way Ad Networks optimize the efficiency of ad monetization has changed. I think it happened slowly enough that we, as consumers, largely didn’t noticed some of the downsides. But other people did. They realized that Ad Networks track us in ways that might feel like an invasion of privacy. So those people started blocking ads.
Even more recently, we’ve started to discover that the mechanisms Ad Networks use to serve and track ad also create horrible performance problems, especially on mobile devices. If pages load slowly in a browser, people notice. If pages start consuming more bandwidth, people notice. If you provide a way to quickly and easily improve performance and reduce data usage, people will try it. I’d even posit that people care a lot more about performance and data usage, than privacy.
Even if you don’t care about the privacy implications of tracking cookies and other technologies sites use to identify us online, you might want to turn on Tracking Protection in Firefox anyway for a potential big speed boost. – Lifehacker
Is there a way for Ad Networks to clean up this mess? Some people inside Mozilla think it can be done, but it will take some effort and participation from the Ad Networks. I don’t think anyone has a good plan yet. Maybe the browser could help Ad Networks do things much more efficiently, improving performance and reducing bandwidth. Maybe people could choose how much personal information they want to give up.
If you fix the performance, data usage and privacy issues – will people really care that much about advertisements?
http://starkravingfinkle.org/blog/2015/09/is-ad-blocking-really-about-the-ads/
|
|
Air Mozilla: TaskCluster GitHub, Continuous Integration for Mozillians by Mozillians. |
TaskCluster GitHub is a CI system built atop Mozilla's own infrastructure. As a result it offers more freedom and flexibility than you'll find from any...
https://air.mozilla.org/taskcluster-github-continuous-integration-for-mozillians-by-mozillians-2/
|
|
Daniel Stenberg: Blabbed about curl at Google |
I was invited by Robert Nyman to speak at Google in their Stockholm offices on August 26th, in his Google Tech Talk series.
“curl – a hobby project with a billion users” was the humble title of the talk.
curl is like a Swiss army-knife for HTTP and internet transfers. For over 17 years the project has been run by volunteers and now counts perhaps more than one billion users. Daniel takes us through how it started, how it works and why it never gets done.
Already back in June all the 70 seats were taken and there were more than twice as many persons in the waiting list by the time the talk was happening! A totally mind-blowing interest I mostly credit Robert’s reach and ability to gather people.
Here’s the video of the talk:
To my great surprise and joy, I got this awesome gift from the host:
(It is an LG Watch Urbane)
http://daniel.haxx.se/blog/2015/09/17/blabbed-about-curl-at-google/
|
|
Air Mozilla: Web QA Weekly Meeting |
This is our weekly gathering of Mozilla'a Web QA team filled with discussion on our current and future projects, ideas, demos, and fun facts.
|
|
Armen Zambrano: Platform Operations lightning talks (Whistler 2015) |
|
|
Nathan Froyd: compiler-enforced locked accesses |
If you’ve done any amount of threaded programming, you’ve probably run across code that looked like:
// Only accessed with the mutex held. uint32_t mFlags; bool mConnected; nsTArray mData; // Only called with the mutex held. void DoSomething();
Perhaps you’ve even gotten to debug code which inadvertently violated the locking requirements of the members.
Several months ago, I reviewed a patch by David Keeler that addressed the second half of the above example. Methods that had locking requirements looked like:
void DoSomething(MutexAutoLock& aProofOfLock);
which ensures (at compile time!) that you can’t call the function without locking the mutex first. I thought this was a nice technique, said as much in my review, and have been looking for places to apply it ever since.
The explicitness and the requirement to constantly pass MutexAutoLock& variables around is a feature, not a bug. Doing so encourages you to limit the amount of code that needs to be executed with locks held, keeping the concurrent parts of the code and the synchronized parts of the code clearly delimited. In this respect, this technique is similar to the IO monad in Haskell. I don’t know whether the extra verbosity would make the code more difficult to read or not, especially if the techniques for guarding members suggested below were applied as well.
This coding style also came in handy a week or so ago investigating overly high CPU usage when playing YouTube videos. Our event queue for nsIRunnables did its own locking internally, and exposed its internal reentrant monitor “for power users”. This led to code like:
{
ReentrantMonitorAutoEnter mon(mEvents.GetReentrantMonitor());
...
mEvents.PutEvent(event);
}
where the PutEvent call would do an extra round of locking (“just to be sure”), which was wasted work. Data structures like this doing their own locking internally typically isn’t a great idea, so part of the work in the above bug was to separate the locking requirements of the queue from who actually needs to do the locking. Or, in other words, we can have the class that owns the event queue do the locking, and have the event queue’s methods enforce the locking programmatically:
{
MonitorAutoLock mon(mMonitor);
...
mEvents.PutEvent(event, mon);
}
Now there’s no wasted work in PutEvent, because it already knows the appropriate locking has been done. The ability to use non-reentrant monitors—which are more efficient—was a nice bonus resulting from the separation of concerns here.
This technique can also help solve the first half of the problem we presented at the beginning of this post: ensuring members are only accessed with locks held.
templateclass Guarded; template<> class Guarded { public: Guarded() : mValue(0) {} uint32_t Value(MutexAutoLock& aProofOfLock) { return mValue; } void Assign(MutexAutoLock& aProofOfLock, uint32_t aNewValue) { mValue = aNewValue; } // Since accesses should only be done under the lock, and copying // and moving would therefore require locks, we require the user // to ensure those constraints are met with explicit calls to the // above rather than the compiler sneaking unlocked accesses in. Guarded(const Guarded&) = delete; ... private: uint32_t mValue; };
The above class isn’t production quality code; it’s intended to sketch out how explicit locking requirements might work. A more robust version might require a Mutex& reference to be passed to the constructor, and member functions assert that the MutexAutoLock& parameters actually lock the specified mutex. Specializing for each of the integer types would also get tiresome, so we’d need to do a better job there. Handling types with methods could be done with something like the following, I think:
templateclass GuardedAggregate { public: GuardedAggregate() : mValue() {} // The core idea here is that the user would write: // // GuardedAggregrate mArray; // // and then accesses would be done via: // // mArray.Value(lock).Method(...); // // This means that we don't have to proxy every single one of // the aggregate's methods, but the locking requirements are // still explicit. class Proxy { public: Proxy(MutexAutoLock& aProofOfLock, T* aValue) : mValue(aValue) {} T* operator->() { return mValue; } private: T* mValue; }; Proxy Value(MutexAutoLock& aProofOfLock) { return Proxy(aProofOfLock, &mValue); } ... private: T mValue; };
This can also be though of as a compiler-independent, but less flexible version of clang’s Thread Safety Analysis. Folks have been asking about bringing the annotations that analysis requires into Gecko; I wonder if it might work just as well to apply this technique more liberally throughout the codebase.
https://blog.mozilla.org/nfroyd/2015/09/17/compiler-enforced-locked-accesses/
|
|
Air Mozilla: Mozilla Web QA: (re)volution of our WebDriver-based Python-testing framework |
In 2011 Mozilla developed and released a pytest plugin that simplified the task of maintaining functional UI tests for over a dozen web applications. It...
https://air.mozilla.org/mozilla-web-qa-re-volution-of-our-webdriver-based-python-testing-framework/
|
|
Aaron Thornburgh: User Study: Personalizing & Organizing New Tab |
Firefox users don’t necessarily want more features on New Tab. They want more value.
Although I had always suspected as much, this was our key finding in two back-to-back studies conducted with nearly 200 participants. The first study sought to determine the degree to which users wanted to personalize their overall New Tab experience. A second was then launched to investigate how much organization users wanted, and how much direct control they preferred.
The results are equally revealing and worth sharing.
+++++
For this we study we tested the current New Tab Controls menu against two other variations which offered either limited or unlimited customization.
Current Version
“I like how clean it is, and how easy it is to choose between the two options.”Today, the New Tab Controls menu offers users a strange choice: Everything or nothing. By default, New Tab displays a search bar, the user’s top sites on the Web, and sites suggested by Firefox. In this view, the only “control” the user has is to disable those suggestions. Choosing the other menu option removes absolutely everything but the cog icon.
“Well, that’s just kinda sad.”Version A
The first variation of the New Tab Controls menu simplified the display to reflect one New Tab page with options to show or hide both a user’s top sites and content suggested by Firefox.
“This one just seems more polished, and more intuitive.”Version B
A second version added to the new layout by including options that allowed a user to change the background color of New Tab, or upload a personal image.
“You can really make it your own. I definitely think this one’s more fun.”Two groups of 48 were sourced from usertesting.com, totaling 96 participants. The first group was shown the current New Tab Controls menu against Version A; whereas the second group was shown Version B instead.
Initially, we ran a qualitative un-moderated usability study with 8 participants in the United States and United Kingdom to observe how they interacted with the new features available in the New Tab prototype. Testers were asked to think out loud as they explored the various menu options, while inputting answers to specific questions for measurable data points.
Afterwards, we ran the same study with 40 more participants (without video analysis) to supplement data gathered from the original 8. Combined, a total of 48 responses were collected.
Download the final report: UserStudy_NT_Page_Controls_V1 (782 KB)
In this study, we showed testers two different ways to organize their sites on New Tab.
Version A
The first prototype offered a menu, labeled “Your Top Sites” by default. Clicking the text launched a drop-down that allowed testers to sort fictional browsing history by recent interest category.
“It’s the simplest thing I’ve seen in a long time, which is why I like it.”Selecting any of the categories displayed just the sites in the user’s history related to that interest.
“It seems redundant and not super useful.”The drop-down menu also provided the option to view all “top 100 recent sites”.
“I’d rather just use a history feed.”Version B
A second prototype showed a group of logos titled “travel.” Testers could click any logo to view the destination page in another tab, expand the group to see larger logos and page thumbnails, or edit the group contents.
“This is a good way to consolidate.”
“The big circle… It’s kind weird.”
“It’s not very obvious how to get back to where I started.”Once again, two groups of 48 were invited to participate in the study, for a total of 96. Group A were shown Filters on New Tab first for a usability study, and then then Groups for sentiment analysis and ultimate preference. Group B were show Groups on New Tab first, and then Filters.
8 individuals from the United States, United Kingdom and Canada were enlisted for an un-moderated usability study. As with the previous test, participants were asked to think out loud as they tried the various features available in each prototype, while answering specific questions for data inputs. 40 additional participants provided supplemental data, totaling 48 responses altogether.
Download the final report: UserStudy_NT_Filters_vs_Groups_V1 (1.5 MB)
Although few usability issues were observed, an interesting patter emerged almost immediately. Nearly all participants indicated that the current New Tab Controls menu was “sufficient”, and many had only a few quibbles with the functionality or presentation.
Then they were presented with either more simplified, “limited” controls, or additional controls that allow for “unlimited” customization of the New Tab background…
1. Users don’t always know what they want
Even though most testers thought the original controls were sufficient, three out of four preferred either one of the alternative versions. In other words, testers explicitly stated they wouldn’t change anything, until they saw something different-but-better, and then they wanted more… or less.
Lesson learned: People lie! They just don’t always know it. It’s our job as experience professionals to see through blanket declarations to uncover the true sentiment. (But sometimes people do tell the truth… Which is we we test things.)
+
2. Rethink rethinking convention
Today, a blue check-mark indicates which view of New Tab a user has selected. But it isn’t a check-box. Several testers tried to click the blue arrow to deselect, instead of rolling over to click the other option. Of course, there is a check-box underneath “Show your top sites,” so this behavior is not without precedent.
Those who indicated that they preferred either of the alternative menus probably did so in response to the restyled controls that were actual check-boxes.
Lesson learned: As a designer, it is always tempting to challenge or replace old conventions with new variations. We must be especially careful, however, because what seems very clear to us may be vague to others. “bespoke controls” are better suited for primary navigation elements because they are often big enough to be understood as single-click destinations to something important. For menus, settings, and discrete functions, it’s often better to err on the side of convention.
+
3. Nothing should ever be all-or-nothing
If there was one thing testers disliked the most, it was the “Show a blank page” menu option. Choosing that view removed every element from New Tab, save the New Tab Controls cog icon. In the words of one testers,
“Not sure why anyone would want that.”
Every single participant observed specifically asked for the search bar to be added to this otherwise empty page. This is maybe why so many participants loved the custom Background Image feature offered, because when they deselected “Show top sites” and “Allow suggested content,” they still saw a pretty picture.
“Background image – that’s more interesting to me.”
Lesson learned: Even taking away the custom Background Color options would afford any user literally infinite possibilities for customization. This example reinforces the sheer power one, well-conceived feature can allow limitless variety; additional controls are not always necessary to enable a satisfying experience.
This is where is gets really interesting.
Unlike other studies, participants were asked at first not to interact with anything, but to describe the first few things they noticed on or about New Tab. We simply wanted to know if testers would find the new features on their own. The responses elicited everything from the affordance of the search bar, styling of the “tiles”, suggested content options, and (sometimes) the features we hoped they would notice. In many instances, individuals described how they actually use Firefox to navigate the Web.
Then they interacted with one prototype, and then the other for comparison. Interpreting the final results was done so through the lens of the experiences mentioned above.
For me, the finding I found most profound was this:
1. A “winner” does not indicate “perfection”
As predicted, Groups was favored by testers – but not by a wide margin. In fact, a handful of participants actually liked both, equally. During video analysis, a few actually wanted to combine the two features in some way.
More importantly, the dominant reason Groups won over Filters always also shed light on the feature’s biggest flaw…
With Filters, a user must click once to launch the menu, click again to select a category, and then a third time after identifying the different, filtered sites shown. That’s terribly inefficient. With a group, a user has to click only once, but from among five additional destinations – all within the same basic tile shape. That is very definition of efficiency, and the reason stated by many as to why they preferred Groups over Filters.
The “expanded” Group view is another story. Even though most enjoyed playing around with the controls for customizing a site’s appearance on New Tab, testers otherwise felt like the expanded view was either redundant or confusing, and far less useful overall.
Understanding what a user values most is what provides the insight necessary to perfecting any feature. In this case, testers had stated that they use New Tab for one primary purpose: navigation. Whichever prototype facilitated navigation better for a particular tester was therefore almost always the version they preferred…
Lesson learned: So, don’t get in a user’s way by loading up New Tab with lots of fancy stuff. Keep it simple, light, and purposeful. Then let users decide if and how they use the features provided to make New Tab their own.
Naturally, all the features we tested were intended to invoke a noticeable reaction. I just didn’t expect the degree to which users actually enjoyed trying out the features (especially custom Background Images). At one point or another, nearly all participants made an unsolicited exclamation of joy or delightful surprise. Personally, this affirms that we’re experimenting in the right ways by exploring features that add user value above everything else.
Also, there is still much work to be done. We cannot, should not, overwhelm Firefox users with “enhancements.” Instead, we need to be purposeful and minimal.
Going forward, I believe that Content Services – and Mozilla at large – now have a clear mandate…
Wherever possible, reduce the number of steps a user has to make to make it personal.
Darren Herman, VP of Content Services
Kevin Ghim, Group Product Manager
Justin Terry, Product Manager
http://autodidacticdesigner.com/2015/09/17/user-study-personalizing-organizing-new-tab/
|
|
L. David Baron: Running animations on the compositor thread |
Support for running animations of 'transform' and
'opacity' on the compositor thread is scheduled to ship
next week in Firefox 41. This has been supported in Firefox OS since
1.0, and is something that a number of other browsers do as well, but
will now also ship in Firefox for desktop and Android.
This means that animations of the CSS 'transform' and
'opacity' properties will run on the compositor thread,
which makes them smoother, because they will continue running smoothly
when the main thread misses its frame budget (that is, when the main
thread stays busy too long to meet the frame rate).
Even better, when we run the animation on the compositor thread, we
stop updating style on the main thread as the animation progresses,
which reduces the total amount of work that we need to do. However, if
the page does anything that flushes style or layout (that is, requests
up-to-date style or layout information, such as
getComputedStyle(), getBoundingClientRect(),
or offsetTop), we recompute the current style on the main
thread.
Running an animation on the compositor thread involves takes some existing optimizations that browsers have and makes them even more effective, which I'd like to explain in a little more detail. When an element has an active layer (a surface into which its contents are painted, that is given to the compositor thread to be composited), we implement transform and opacity by setting transform or opacity on the layer and having the compositor apply the transform or opacity when compositing. So when we want to run an animation on the compositor thread, we:
Even when we support off-main-thread compositing we don't run
transform and opacity animations on the compositor thread in all cases.
The biggest is that we don't support compositor-thread animation of 3-D
transforms in a preserve-3d scene. This means that if an element or its
parent uses 'transform-style: preserve-3d', we don't run
animations of its transform on the compositor. This is something that
we hope to fix quite soon. Also, if the animation is also animating
height, width, top, right, bottom, or left, then we do not run transform
animations on the compositor because they would get out-of-sync with the
size or position changes coming from animations of those other
properties. We also don't support compositor-thread animation of
elements with SVG transforms.
[Demo added 22:50] If you want to see the benefits, you can compare this demo of the smoothness benefits between Firefox 40 (or older) and Firefox 41 (or newer).
Many people contributed to getting this shipped. I'd particularly like to thank David Zbarsky (who implemented sending animations to the compositor thread and running them there), Nick Cameron (who implemented suppressing the work we do for such animations on the main thread), Brian Birtles, Robert O'Callahan, Chris Jones, Matt Woodrow, Boris Zbarsky, Markus Stange, Jonathan Watt, Cameron McCormack, Alice0775 White, Virtual_ManPL, and Elbart.
(I'd also note that we've often called this project OMTA or off-main-thread animations. However, since the animations are specifically running on the compositor thread, I prefer to call it that.)
Related links:
|
|
Daniel Stenberg: a curl cheat sheet |
MOAR DOX!
Whenever we ask curl users what they lack in our project and what we should improve, the response is always clear: documentation.
Here are the most common curl command line options when doing HTTP operations. This is the web page rendered as an image, click it to get to the web version.
The source for the document/image is on github. As always, you can help improving it.
|
|
Air Mozilla: Quality Team (QA) Public Meeting |
This is the meeting where all the Mozilla quality teams meet, swap ideas, exchange notes on what is upcoming, and strategize around community building and...
https://air.mozilla.org/quality-team-qa-public-meeting-20150916/
|
|
Air Mozilla: Product Coordination Meeting |
Duration: 10 minutes This is a weekly status meeting, every Wednesday, that helps coordinate the shipping of our products (across 4 release channels) in order...
https://air.mozilla.org/product-coordination-meeting-20150916/
|
|
Air Mozilla: The Joy of Coding (mconley livehacks on Firefox) - Episode 27 |
Watch mconley livehack on Firefox Desktop bugs!
https://air.mozilla.org/the-joy-of-coding-mconley-livehacks-on-firefox-episode-27/
|
|