Planet Mozilla

Alexander Surkov: Firefox 11 for AT developers

noreply@blogger.com (Alex Surkov) — Wed, 08 Feb 2012 09:38:36 +0000

Here's an update what's new in Firefox 11 (beta, release on March 13) for assistive technology developers.

HTML

CSS generated tables (CSS display:table style) are exposed as layout tables. Originally this piece of work was targeted to Firefox 10 but we weren't in time to make this happen.

HTML table cells (HTML th and td elements) gained new not standard axis and abbr object attributes.

The axis object attribute is direct mapping of HTML @axis attribute. This object attribute is supposed to help AT to extract semantic of rich HTML tables in the web. Granted, this HTML attribute is not wide used on the web but we wanted to break the chicken-egg problem: browsers/AT don't support it iff web authors don't use it.

The abbr object attribute is less academic than previous one and useful to pick up short accessible name for header cells, for example, it makes sense when the user traverses through table cells and screen reader announces related heading information for each cell. The user doesn't want to hear long header cell names on and on: that's what abbr object attribute is supposed to help to. This object attribute is exposed in two cases:

HTML abbr element is inside the table cell
@abbr attribute is used on table cell

Examples:

  <th id="th1"><abbr title="Social Security Number">SS#</abbr></th>
  <th id="th2" abbr="SS#">Social Security Number</th>

HTML acronym and abbr elements allow @title attribute for accessible name computation. This can be illustrated by following example:

  <input id="input">
  <label for="input"><acronym title="O A T F">OATF</acronym></label>

Accessible name of input accessible is "O A T F" now.

HMTL5

HTML5 figure and figcaption elements are now accessible. The figure element is exposed with generic MSAA ROLE_SYSTEM_GROUPING and ATK ATK_ROLE_PANEL roles because neither IAccessible2 nor ATK provide more suitable roles. AT can rely on xml-roles:figure object attribute to detect figure element. HTML figure element picks up accessible name from figcaption element which is exposed with IA2_ROLE_CAPTION / ATK_ROLE_CAPTION role. The figure and figcaption accessible objects are linked by LABELLED_BY / LABEL_FOR relations.

The content of HTML5 canvas element is not accessible still but Firefox 11 started to expose an accessible object having IA2_ROLE_CANVAS/ATK_ROLE_CANVAS role for canvas element itself. Not big deal but it's a good first step on canvas accessibility.

ARIA

ARIA attributes used on HTML file element (input@type="file") are propagated to underlying text field and "Browse" button, i.e. accessible states defined by these attributes are inherited.

ARIA combobox (@role="combobox") fires MSAA EVENT_OBJECT_VALUECHANGE event and ATK accessible-value signal when option is changed. Here's an example of ARIA combobox widget.

Correctness

IA2_STATE_ACTIVE/ATK_STATE_ACTIVE state is exposed on active item for standard composite widgets like HTML select elements. The state can be used for example to detect the current item of the widget when the widget isn't focused. We make our implementation closer to ARIA widgets where aria-activedescendant technique is used. Another side of this code unification is IAccessible::accSelect called with SELFLAG_TAKEFOCUS flag can be used on widget items now.

Small fix for IAccessible::get_accName that returns S_FALSE when the accessible object doesn't have accessible name. Not big deal. Done for consistence and meet MSAA spec.

Bonjour Mozilla: Nikola Matosovic

clarista — Wed, 08 Feb 2012 09:00:00 +0000

(Photo : Brian King)

Il est le visage emblématique de la communauté Mozilla en Croatie et vient de publier un billet sur son blog rédigé sur 3 mois dans lequel il raconte par le menu ses premiers pas aux côtés du Panda Roux en tant que Reps. Ambitieux, Nikola Matosovic est bien décidé à bâtir une communauté importante dans son pays… Et c’est bien parti ! Il a déjà réussi à convaincre quelque 30 personnes de contribuer à Mozilla ! Il faut dire que Nikola est un remarquable organisateur, ainsi qu’un garçon enthousiaste et très sociable. C’est donc logiquement qu’il est candidat pour accueillir le prochain MeetUp pour les Balkans.

Bonjour Nikola ! Et merci !

PS : Bonjour Mozilla serait motivé pour participer à ce meetup ;-)

He is the iconic face of Mozilla community in Croatia and has just published a post on his blog written during about three months in which he tell in detail his first steps with the Red Panda as a Reps. Ambitious, Nikola Matosovic is determined to build a large community in his country… And he started well with 30 people already convinced to contribute to Mozilla! I must say that Nikola is an outstanding event organizer and a very enthusiastic and sociable boy. He is therefore logically volunteering to host the next Balkan MeetUp.

Bonjour Nikola! and thank you!

PS : Bonjour Mozilla would be very happy to participate to this meetup ;-)

Brett Gaylor: Mozilla Popcorn aka The Meme Generating Machine

Wed, 08 Feb 2012 05:28:00 +0000

meme ( /ˈmiːm/) “an idea, behavior or style that spreads from person to person within a culture.”

“A meme is an idea that behaves like a virus—that moves through a population, taking hold in each person it infects.” - Malcolm Gladwell”

We need Mozilla Popcorn to become a virus.

Hear us out here.

In our early iterations of Popcorn Maker, we’ve been tackling the problem of how to make it easy for non-programmers to create Popcorn experiences. It remains the central focus of the project, and we’ve fleshed out our User Stories to imagine the full experience that a user might have. Ben has described these stories in a recent blog post.

During our Popcorn Maker sprint, we put a lot of thought into imagining how our users’ creations will get shared and disseminated on the web. Ben has blogged about how Popcorn.js is a gateway drug to learning JavaScript (Also of the good sort. Stay with us). Similarly, we want Popcorn Maker to be a tool for injecting the Maker meme onto the web.

Fork my meme

To do this, we’ll need to do a few things. First, we need to make it easy for Popcorn makers to embed their creations on their own blogs, Tumblrs and websites. This means offering embeds.

More interestingly, we want to give viewers the ability to fork others’ Popcorn productions. If you’ve watched Jonathan MacIntosh’s Buffy Vs Edward pop-up video remix, for example, wouldn’t you love the ability to easily clone his creation and add to it?

Each Popcorn creation needs a post-roll that offers viewers the ability to 1) Replay, 2) Share and embed, and 3) Fork this creation.

Popcorn Gallery

To build WordPress-like community scaffolding, we need the ability for every single creation to be made available in the Popcorn Gallery. When users choose to [Share] from Popcorn Maker they have an option to share to the Gallery that is checked by default. While the Gallery will favour our default templates, it will become a jumping off point for new creators to get started with Popcorn. It will solidify the notion that creating on the web is generative. The act of creation will start by building on someone else’s work.

We think Popcorn will be a good bug to catch. Like getting the chicken pox when you were a kid. Or maybe more like taking an interest in photography. We’re sure this is the right metaphor. Note: knock knock jokes, box stores and lolcats were all considered as alternatives while titling this post. Go meme or go home.

Web Made Movies: Roadmap Popcorn Maker 1.0

ben — Wed, 08 Feb 2012 05:23:23 +0000

We are hard at work on Popcorn Maker.

Currently at version 0.1, Popcorn Maker is a little crufty. But Popcorn Maker 1.0 will hit hard in November of this year.

Popcorn Maker 1.0 will empower you to make cool web-based media, whether you’re a beginner or pro. With over 20 plugins—ranging from Twitter to Google Maps to video processing—you’ll be able to stitch up a stylish video that’s “woven” into the web. And, of course, it’s 100% free and open source.

Users will be able to publish and share their creations on their blog, Twitter, or Tumblr (or just grab the code). And the app will reward them for learning more advanced HTML, CSS, and Javascript skills.

When it hits critical mass, Popcorn Maker will be an engine for community innovation in open video.

I blogged about the Popcorn Maker vision in July of last year. Since then, it’s moved to the center of the Foundation’s “Maker” strategy for 2012.

Roadmapping

Last week—thanks to four intense, caffeine-fueled days—the project team arrived at a pretty solid roadmap and vision for Popcorn Maker. Our issue tracker also includes several hundred new/reassigned bugs, mapped against cheeky code names for each release. (We’ve chosen a blockbuster movie motif, so look forward to 0.2 Ghostbusters, 0.3 Breakfast Club, 0.4 Top Gun, 0.5 Pulp Fiction, 0.6 Terminator, 0.7 Amelie, 0.8 Rushmore, 0.9 Wrath of Khan, and finally, 1.0—Matrix.)

What’s new? A heightened level of ambition, matched with increased rigor to get it done.

Starting in 0.7, you'll be able to embed a viral Popcorn player on third-party sites.

Importantly, we’ve developed a working theory of how Popcorn can become a webmaking virus, which Brett Gaylor has blogged about here.

All of this is reflected in a shiny vision document, which is a work in progress (we’ll share next week). We’ve hashed out some user stories, gotten granular on the technical challenges, and imagined how the UI/UX might work. We need to kick the tires a bit before we’re confident in both the user stories and the roadmap, but we’re close.

We’d love to have your feedback in our Lighthouse issue tracker. (And, as always, we’d love to hear your template ideas! Feel free to create a ticket and let us know what’s on your mind.)

Here’s a look at some of our thinking.

Editor UI

Most users will experience the app as a special editor tray that sits on top of the project you’re working on (Popcorn Maker is a WYSIWYG tool). We need to get the editor UI/UX right. It needs to be compact but not constraining.

We’re moving event editors to the tray (in lieu of floating windows) and making it more intuitive to add Popcorn events to a page (just drag and drop onto the page target).

To make the app more versatile, we’ll offer a simple CSS editor UI to change your styles, without isolating you too much from the actual CSS:

Popcorn Gallery

The life-force of Popcorn Maker will be the Popcorn Gallery, which will let contributors share templates that others can build on. Call it the “WordPress.org effect.”

Plugins

You can use any popcorn.js plugin in Popcorn Maker. Even write your own.

Last but not least—plugins. Popcorn.js plugins are what make Popcorn Maker magic. We’re currently planning on supporting the following plugins, each with a pleasing editor UI (these are subject to change): Image, Video, Webpage, Wikipedia, Attribution, Media control, Apply class, Google map, Open Street Map, Chroma, Video effects, 3D object, Processing, WordRiver, PDF, DocumentCloud, Twitter, Facebook graph, Flickr.

One of the coolest things about Popcorn Maker, though, is that it will support every Popcorn.js plugin through a default editor. And plugin authors can create editor UIs for their plugins. In other words, the project is intentionally modular, so the Popcorn.js community can help us build out the functionality of the app.

As the community grows, the app becomes more powerful.

Seriously. Check out Seriously.js, then read that again.

Roadmap—want to help?

It’s going to be a hard sprint. But it’s super plausible, especially with Bobby Richter, Dave Humphrey, and the brilliant students of Seneca’s CDOT at the wheel. Here’s our roadmap, which will likely change a bit before we freeze it this month. Want to help? Join #popcorn in irc.mozilla.org, or join our mailing list.

Web Made Movies: Mozilla Popcorn aka The Meme Generating Machine

brett — Wed, 08 Feb 2012 05:12:46 +0000

meme ( /ˈmiːm/)
“an idea, behavior or style that spreads from person to person within a culture.”

“A meme is an idea that behaves like a virus–that moves through a population, taking hold in each person it infects.” – Malcolm Gladwell”

We need Mozilla Popcorn to become a virus.

Hear us out here.

In our early iterations of Popcorn Maker, we’ve been tackling the problem of how to make it easy for non-programmers to create Popcorn experiences. It remains the central focus of the project, and we’ve fleshed out our User Stories to imagine the full experience that a user might have. Tthese stories have informed the foundational changes to Popcorn Maker that Ben outlined in a recent blog post.

Fork my meme

To do this, we’ll need to do a few things. First, we need to make it easy for Popcorn makers to embed their creations on their own blogs, Tumblrs and websites. This means offering <iframe>embeds.

Each Popcorn creation needs a post-roll that offers viewers the ability to 1) Replay, 2) Share and embed, and 3) Fork this creation.

Popcorn Gallery

While the Gallery will favour our default templates, it will become a jumping off point for new creators to get started with Popcorn. It will solidify the notion that creating on the web is generative. The act of creation will start by building on someone else’s work.

We think Popcorn will be a good bug to catch. Like getting the chicken pox when you were a kid. Or maybe more like taking an interest in photography. We’re sure this is the right metaphor.

Note: knock knock jokes, box stores and lolcats were all considered as alternatives while titling this post. Go meme or go home.

Ben Moskowitz: Roadmapping Popcorn Maker 1.0

Ben Moskowitz — Wed, 08 Feb 2012 04:51:31 +0000

Currently at version 0.1, Popcorn Maker is a little crufty. But Popcorn Maker 1.0 will hit hard in November of this year.

When it hits critical mass, Popcorn Maker will be an engine for community innovation in open video.

I blogged about the Popcorn Maker vision in July of last year. Since then, it’s moved to the center of the Foundation’s “Maker” strategy for 2012.

Roadmapping

What’s new? A heightened level of ambition, matched with increased rigor to get it done.

Starting in 0.7, you'll be able to embed a viral Popcorn player on third-party sites.

Importantly, we’ve developed a working theory of how Popcorn can become a webmaking virus, which Brett Gaylor has blogged about here.

We’d love to have your feedback in our Lighthouse issue tracker. (And, as always, we’d love to hear your template ideas! Feel free to create a ticket and let us know what’s on your mind.)

Here’s a look at some of our thinking.

Editor UI

We’re moving event editors to the tray (in lieu of floating windows) and making it more intuitive to add Popcorn events to a page (just drag and drop onto the page target).

To make the app more versatile, we’ll offer a simple CSS editor UI to change your styles, without isolating you too much from the actual CSS:

Popcorn Gallery

The life-force of Popcorn Maker will be the Popcorn Gallery, which will let contributors share templates that others can build on. Call it the “Wordpress.org effect.”

Plugins

You can use any popcorn.js plugin in Popcorn Maker. Even write your own.

As the community grows, the app becomes more powerful.

Seriously. Check out Seriously.js, then read that again.

Roadmap—want to help?

Jess Klein: Day 2 of Open News Sprint- Design for Empathy vs. Pure Utility

noreply@blogger.com (Jess) — Wed, 08 Feb 2012 04:48:22 +0000

Day 2 of the Open News Webmaking Design Sprint kicked off with a storyboarding session- which of course meant a round of the color coding index card game! Basically what we did was come up with three categories of things that we were sketching out the flow for:

Main Screens and Modal Windows (pink cards)
Content in the Instructional Overlay (orange cards)
Badges (green cards)

*Note- I will post the full storyboards later this week

One thing that was an interesting change from yesterday's conversation was that we converted the "sharing" steps into information that can be revealed and explored when the user clicks on the "share" button, thus eliminating that extra step.

In terms of the badges, for simplicity we came up with one badge per each skill set. So, for example, in the image below- we sketched out 3 steps for learning about how to write the html for embedding an image into a webpage. Step 1- place an image that we give them, Step 2- hack that image with an unique image and Step 3- Remix that Image--- then the user will receive an Image Badge. Completion of all the Modules will give the user the "uber badge". (We need real names for these badges, but this is just a concept).

One thing that we talked about- which is out of scope for this pilot prototype- was having a user pledge for the badge by going through a series of interactive activities or games or questions... to prove their skill. It's a bigger idea that certainly relates back to integrating this badge into a larger spectrum of "Mozilla Badges," but I like this idea because on some level it proves competencies and could essentially allow users to skip other "intro" activities in courses or interactives.

Atul, Brian and I spent a bit of time trying to figure out how we were going to implement the designs into a working prototype, a small- yet crucial step. Good news, we think we can make something by the end of this week.

The group had a great conversation about metrics for the project that I think we will rehash again after we create the MVP (that's a minimum viable product not a most valuable player). This is what we came up with as a first stab:

Beyond-the-tool Metrics

How many people share their URL outside of the tool (twitter, blogs, etc.)
3-months-later survey of people who graduated

Tool usage measurement metrics

How frequently the user switches away from the page (to another tab, app, etc) while using the app
How many steps people go through
How many of those steps are repeated
Time taken per step
How many people are return users to the website; so they use the tool and stop at a certain step and then come back at a later date to continue
and what are those stop points?
Also, how many people graduate from the 'course' (tricycle) to the 'tool' (training wheels), ie. how many people turn off the overlay and keep coming back, how many times.
How many people do the bare minimum (just the tutorial)
What link text people use when writing links and how many links are they putting in
How many people come back to pledge for the full badge?
How many people go above and beyond with tinkering

i.e multiple images, all the "optional" styles, etc.

We spent the remainder of our jam packed day focusing on copywriting. We had a conceptual conversation about what direction the tool should take, which of course affected the way that we wrote the copy. Because we couldn't agree on whether this should be a generic webmaking 101 tool, a tool focused on helping people tell their story through the web or a tool geared towards journalists we decided to write as much of the technical bits and pieces as possible and to come back and add on the layer that included narrative, voice and character.

Today I am feeling a bit conflicted about the design direction. In my heart I believe that the project should be a self directed interest based learning tool- which means a tool that helps someone make something and then baking in the learning seamlessly. I am concerned that if we go too generic we will end up with a tool, that people can't relate to and thus won't feel compelled to deep dive into the learning content. So that said, I guess this just is about deciding between the "telling your story" vs. "webmaking for journalists 101". As I said before, I like the telling your story through the web angle for the product because it is something that is easy for many different kinds of users to relate to. This is about branding- and by branding I don't mean slapping a logo on the project and calling it a day- it is about creating a narrative for the project that is compelling enough to give users and potential users the opportunity to empathize and relate to the project on a deeper level.

For example- if the lovebomb.me experimental project was a tool it might be called something like e-card maker. I suspect that people would not have responded so strongly to that project. We built in a narrative and a real directive- make a love letter for a friend- and wrapped that into a light narrative heavily supported by cute lovey-dovey graphics. Well, this conversation is to be continued later.

Tomorrow we will be meeting real live journalists, so I am excited to ask them about what they really are interested in making with the web. Hopefully this will inform the direction of the project.

Nicholas Nethercote: MemShrink progress, week 34

Nicholas Nethercote — Wed, 08 Feb 2012 04:35:18 +0000

Add-ons

The AMO add-on review checklist was amended a couple of weeks ago to include checks for zombie compartments. This change is bearing fruit: Andreas Wagner and Kris Maglione have found more than 10 submitted add-ons that have leaks. See here, here, here, here, here. With the experience they are gaining, we should be able to greatly improve the documentation on common causes of leaks.

In less positive news, two leaks were found in the add-on SDK. Fortunately the SDK team has proven to be effective at fixing identified leaks quickly in the past, hopefully they’ll do so again!

Finally, Jason Tackaberry fixed a zombie compartment in NoSquint 2.1.2. The fix is in the latest version (2.1.5).

about:nosy

Andrew Sutherland wrote a extension called about:nosy which is like about:memory on steroids. It’s oriented around hiding many of the details and instead assigning blame for memory allocations to particular tabs (and similar things). It also features graphs showing how the memory consumption of each tracked entity changes over time; this latter feature is quite memory and CPU-intensive, however. If you are running a recent Nightly build of Firefox, download about:nosy here and you won’t even have to restart Firefox to see it, just type “about:nosy” into the address bar.

Forthcoming changes will make about:memory more like about:nosy, by measuring more things on a per-tab basis. And for a long time I have had a vague plan that one day someone who knows about UX will write a user-friendly alternative to about:memory that focuses just on per-tab memory consumption, and about:nosy is a good indicator of what that might look like.

Miscellaneous

Saptarshi Guha from the metrics team did an analysis of the physical memory consumption of Firefox 10, 11 and 12, based on telemetry data. The post is heavy going for those who aren’t experts at statistics and R, but the two main conclusions of interest are (a) that add-ons significantly increase resident memory consumption, and (b) Firefox 12 is consuming more resident memory than Firefox 11. This latter fact matches something we’d seen in today’s MemShrink meeting when looking at data from John Schoenick’s in-development version of areweslimyet.com — something in early January caused a significant memory consumption regression. John is working on narrowing down which change caused this.

Gian-Carlo Pascutto overhauled the safe browsing implementation. I don’t claim to understand this change at all, but I think it reduces memory consumption when the database is updated. Better explanations from those who understand this change are welcome!

I reduced the amount of memory allocated when generating about:memory by roughly 30%.

I wrote a detailed discussion of the benefits of reducing memory consumption.

Bug Counts

Here are this week’s bug counts.

P1: 22 (-0/+0)
P2: 134 (-4/+8)
P3: 75 (-3/+4)
Unprioritized: 2 (-2/+1)

Meeting Notes from the Mozilla community: SeaMonkey Meeting Minutes: 2012-02-07

Jesper Kristensen — Wed, 08 Feb 2012 04:00:11 +0000

SeaMonkey/StatusMeetings/2012-02-07

< SeaMonkey | StatusMeetings

« last meeting | index | next meeting »

SeaMonkey Meeting Details

Time: 7 February, 2012, 13:00 UTC
Location: #seamonkey IRC channel

Agenda

Who’s taking minutes? -> Ratty
Nominees for Friends of the Fish Tank:
- Please note A person or entity can’t be nominated twice in a row.

Action Items

(who needs to do what that hasn’t been recorded in a bug) We should assign people to the open items.

NEW

OPEN

IanN to write the “Friends of the Fish Tank” F.A.Q.

Status of the SeaMonkey Buildbot Master and Tree

Current Issues with existing machines
- one linux VM — Hosted on parallels, kernel panicking, No bug yet, but will get it done ASAP.
- problems with creating a second linux VM — will either fix or reclone this week.
- one win VM, switched from FAT32 to NTFS for one of its drives, need to recreate folders appropriately.
“Where do we stand with the machine(s) right now?”
- bug 721516 migrate seamonkey systems out of sjc1/scl2 and into scl3/scl1.
  - (2012-02-02) The iX boxes are now located at SJC1 they have been put into production for Callek and team.

Release Train

2.7b4 was shipped on January 20
2.7b5 was shipped on January 26
2.7 was shipped on January 31.
2.8b1 was shipped on February 4.

Extensions Compatibility Tracking

We need some help with the add-ons listed under the “2.0x” heading. Anything above it will work out of the box with SM 2.7 and later (yay to compatible-by-default!). Perhaps Ratty can go through his xSidebar site and check which add-ons are not compatible with at least SM 2.1 – that would help, too.

Since xSidebar itself is not compatible with any recent SM version, it should not be listed as a featured add-on on AMO. Who can make that change?
- KaiRo can, InvisibleSmiley will check talk to KaiRo about that.
- If anyone wants to suggest add-ons to be featured, send them to InvisibleSmiley (in manageable doses that is).

Addon Compatibility Listings, mostly maintained by InvisibleSmiley
- Recent changes can be found here.
- Restructured for compatible-by-default.
ACR 1.0.3 has been released with a fix for broken AOM search.
Enigmail provides versions for release (AMO) and all branches (Enigmail nightly page). The current release is compatible with both 2.5 and 2.6.
Lightning provides versions for the current stable and beta releases (AMO) and nightlies for trunk and Aurora (Calendar Versions page). Lightning 1.3b1 which works with SM 2.8b1 is available from AMO (Development Channel).
Firebug is compatible but not flagged as such on AMO (depends on automatic tests being set up and run on the Firebug side: bug 680837, needs a Python coder). Stable Firebug version 1.9.x works with any recent SM version. FB 1.10a1 works with trunk, 1.10a2 is broken but 1.10a3 should be OK again (cf. FB issue 5188).
Besides the above, we should also take a look at other add-ons that are important for our users when they switch to 2.x.
- Useful query: https://addons.mozilla.org/en-US/seamonkey/extensions/?sort=popular
The SeaMonkey Features page links to sub-pages for all recent SM versions, including those in development. Please help InvisibleSmiley add major features to the respective pages, ideally as they land. These pages are used when creating release notes, so the more up-to-date the better.
bug 666303 (Seamonkey 2.1 is detected as Firefox 2.1 on the Add-on Site) and bug 671085 Confusing compatibility error when visiting Firefox listing page using SeaMonkey)
- We don’t have a dedicated person here who understands how AMO really works, who to contact in order to actually get things moving etc. Unfortunately. Someone needs to sit down and find the offending logic, wherever it may be (probably in the AMO source, wherever that is).

2.x (Last, Current, Next)

2.6 had ~67,000 and 2.7 had ~21,000 ADU by last Thursday and 2.6.1 has had ~105,000 and 2.7 has had ~20,000 downloads so far.
- Of the released versions, as of last Thursday, we have 17.7% on 2.0, 6.3% on 2.1-2.3, 5.3% on 2.4, 5.3% on 2.5, 49.3% on 2.6 and 16.1% on 2.7. So, in the last two weeks, ~3k (an additional 2.7% of ADU) have migrated to 2.5 or above.
Still a large chunk of users on 2.0.x.
Figure out what is preventing people from moving from 2.0.x to the latest versions.
- Some people cannot upgrade due to system requirements (OS version, processor capabilities etc.)
- Perhaps putting resources into getting certain extensions working with SM 2.4 and above (those that won’t work with SM 2.7 automatically due to compatible-by-default extensions).
- Still need volunteers to look at what is keeping people at below 2.4. IanN could try knocking something up and send it round members lists for polishing but he’s not on all the channels (mozillazine, etc) to post it to when finished.
- Are some Linux distributions are still stuck on 2.0? We have data on OSes and OS versions in the raw data in the Mozilla metrics, AFAIK, Callek now also has access to that.

Usual reminders:

Please make sure that anything that landed on comm-beta (for TB) or mozilla-beta (for FF) which affected non-shared code and which fixed regressions will be fixed on our side, too. Please mark bugs we feel *need* to land on a particular train tracking+ or tracking? so that when we to do a release we can be sure that we don’t miss anything.
- Priority should be given to fixing regressions ASAP. Also keep an eye on and prioritize bugs to be ported from FF/TB that land on branches (Aurora, Beta). We need to keep an eye especially on Session Restore, Sync, Tabbrowser and Address Book.
- Be careful not to break code shared with Thunderbird, otherwise patches might have to be backed out of string frozen repositories.

2.7

open tracking (0)
tracking requests (0)
targeted (0)
fixed (30)

One tracked 2.5 issue still open.
- 2.1 through 2.7 have NOT included the ka locale. The last release with ka locale shipped was 2.0.14 and the ka l10n maintainers have not yet updated for changes in later SeaMonkey versions.
- Callek now needs to morph bug 667147 into removing |ka| from our [current] automation entirely (all-locales). Callek will look at best locale to transition any ka users to.
- Callek isn’t here at the moment (timezones), so ewong will talk to Callek about the ka locale later.
The New 2.7 Features page has a comprehensive list of features.

2.Next

InvisibleSmiley created a restartless add-on (available on AMO) for SM 2.8 (now in Beta) which adds an “Add-ons” options to the list of engines on the Sync pref panel.
Remember to help update the New Features pages as we go along.

Feature List, Planning

Bug statistics for last two (full) weeks: 50 new, 28 fixed, 14 triaged.

Medium triaging effort.
Good further triage targets could come out of looking at the component bug counts, pick yours!

Open reviews/flags:
25 review
9 super-review
0 ui-review
8 feedback

Major wanted/needed features:

Active

bug 606683 Allow customization of toolbar in Composer and MailNews Composition [IanN].
- Progressing slowly, still waiting on reviews from TB side. Full customization has to go to 2.next (currently 2.6 but could be pushed back further) as it needs work on TB too which is taking a while to get reviews on, plus feedback from kaze.
- IanN is still wading through the unpicking of Composer/Mail Compose code in the dependent bugs. After that he will be reworking his customising patches.
bug 477845 Build a standalone (Comm-central) Composer. [kaze]
- kaze has done a bit of work in this bug recently. Building on Windows works. Now supports debug builds on Linux if tests are disabled (–disable-tests). Still a lot to do.
- The standalone Composer patch has to be rebased and fixed for MacOSX.
- Kaze is considering moving Kompozer to an addon so that we can reuse the dialog boxes but start fresh for the content part. Also we can then use the current devtools. KaiRo told kaze in Berlin it seemed a good idea, as it could allow to run a Composer *tab* instead of a Composer window.
- Kaze working on it on hi spare time, with an Indian contributor.
- IanN was supposed to help get builds working with --enable-tests.
  - Will look into this once he gets his customization patches reworked.
Real full-screen (bug 610509) and DOM full-screen (bug 701714)
- patches provided by Mnyromyr and InvisibleSmiley. Otherwise stalled. :-(

Needing help, Unowned, Stalled

Kill-RDF:
- bug 657607 Port jminta’s kill-rdf to SeaMonkey where applicable Part 2 [meta].
- bug 657604 Remove the RDF global object. [serge]
bug 436794 Enable Mac OS X system address book per default and add UI.
- SM UI needed, unowned, helpwanted.
bug 449728 Drag tabs between windows.
bug 477840 Backport KompoZer to Composer (Depends on bug 477845).
- kaze has done a ton of work there. We still need to work out some organizational issues. At the moment there is no active interest from MoMo for bringing standalone composer into comm-central. That’s something we (KaiRo and kaze) will have to negotiate with the Thunderbird team (Standard8).
bug 507841 Port Bug 422814 – Make account configuration quick, easy, and more secure (autoconfig, Quick Account Setup).
bug 533908 SeaMonkey Mail: tabs not restored [misak].
bug 523274 Complete new default theme icon set.
- A list of TODO icons is up in the bug.
bug 526210 Update the icon set for the SeaMonkey Modern Theme.
- bug 548778 New communicator icons (based on Strata theme) for SeaMonkey. Some proposed icons got posted, we should take a look how to get that contribution into the product.
- The rest is unowned so far.
bug 87098 [SeaMonkey] Delete key should delete location bar history list entry.
- Note: Our location bar history doesn’t and can’t use autocomplete at all.
bug 677484 Individual SeaMonkey components are not properly handled by the Windows 7 taskbar.
bug 654009 Reply to list: automatically determine From: address
- Note: The actual task here is to port bug 45715 “Reply to List” [button/(context) menu item]
bug 664309 Make the built-in ChatZilla display a cZ icon in SeaMonkey (now helpwanted)

Roundtable – Personal Status Updates

Status Updates from developers – what are you working on, what’s the progress, any other comments? (feel free to add yourself to the list if your name is missing and you have interesting status).

aceman has been doing some work that touches SM as well as TB especially around feeds, which is good stuff.

Aqualon

asrail

Callek

Completed Release Engineering tasks:

bug 673834 Obsolete ReleaseRepackFactory, fold logic into CCReleaseRepackFactory.
bug 720918 (SM2.7b5) Tracking bug for build and release of SeaMonkey 2.7b5.
bug 721584 (SM2.7) Tracking bug for build and release of SeaMonkey 2.7 Final.
bug 722065 Obsolete GenerateCCTestBuilder.
bug 722940 codesize upload broken for SeaMonkey [and Thunderbird] due to tools dir being incorrect.
bug 724480 Update function on nightly non-functional since version bump to 2.10a1.

Build Config fixes:
Other fixes:

bug 715802 Move quirks triggering into nsSuiteApp.cpp because bug 696376 caused our quirks to be triggered too late.
bug 724336 SeaMonkey News XML causes errors (website).

Working on:

No Bug — Bring up Win2k3 iX Machines, and install MSVC2010.
bug 560772 Make use of mozilla::services for comm-central.
bug 607392 split tagging into en-US and other (RelEng).
bug 722262 Port |bug 552864 Throw away wrapper shell script on unix and lazily load libxul| to SeaMonkey.
- bug 704835 Use a pre-generated nsXREAppData struct instead of application.ini. [SeaMonkey Part].
bug 724791 Bring GenerateCCBranchObjects up to date (RelEng).

ToDo:

bug 655399 Backout CSS change from bug 655395 once SeaMonkey can use it.
bug 722448 Close PasswordAuth ssh access on cn-sea-qm-centos5-01.nl.mozilla.org.
bug 591848 SeaMonkey linux and Windows machines need device support for sound enabled.

ewong

Fixed:
- bug 717493 – Port |Bug 717491 – “Warning: package error or possible missing or unnecessary file: bin/components/proxyObject.xpt (package-manifest, 151).”| to SeaMonkey

Needs Review:
- bug 707786 – Use Services.prefs instead of preferences-service / gPrefService, in SeaMonkey

Working On:
- bug 722767 – Change buildbot configs to upload symbols to symbols1.dmz.phx1.mozilla.com
- bug 723839 – Tracking bug for build and release of SeaMonkey 2.8 Beta 1

To Do:
- bug 633937 – Port bug 562048 to suite.

IanN

Usual testing, reviewing and commenting.
Fixed:
- bug 719080 [en-GB] Search Engine modification for SeaMonkey
- bug 705458 [en-GB] add Twitter Search Engine for Fx (en-GB)
- bug 722758 Print button is misaligned in the Mail & News toolbar with the Modern theme
Waiting for review on:
- bug 638643 Remove obsolete EditorToggleParagraphMarks from editor.js
Waiting for dependent bug to be checked in:
- bug 720661 Display account central when no default account / no accounts setup
Waiting for additional review on:
Reviewed and waiting for feedback from mobile peer:
- bug 689253 Update en-GB for Mobile 10.0 (comm-aurora)
Working on:
- Contacting people affected by proposed changes to Project Areas.
- bug 606683 Allow customization of toolbar in Composer and MailNews Composition
- bug 639690 [META] Re-arrange code between editor and editorOverlay
- bug 657234 Move pasteQuote and pasteNoFormatting into contentAreaContextOverlay
- File/Folder selection in windows.
To Do:
- bug 639395 Get cmd_fontSize to reflect current state of selected content / content at caret.
- Prefs-in-a-tab.
- Create FAQ for Friends of the Fish Tank.
- Knock something up finding out why users are not upgrading to 2.4+ and send it around members lists for polishing.
- Help get composer standalone builds working with –enable-tests.

InvisibleSmiley

Fixed:
- bug 724311 Start page JS (upgrade nagging) fails to identify 2.10a1 nightly correctly
- bug 724076 Update SeaMonkey website for 2.8 Beta 1
- bug 722405 Update SeaMonkey website for 2.7 Final release
- bug 721881 Port |bug 666306 – Video content should become large play button …| to Modern
- bug 721583 Make lightweight themes / Personas work in the Download Manager window
- bug 721286 Update SeaMonkey website for 2.7 Beta 5
- bug 721021 Port |bug 593321 – Opening saved .EML with empty subject has wrong window title|
- bug 712699 Create/Update 2.7 Release Notes
- bug 713087 Port |bug 534956 – Sync add-ons| (restartless add-on for SM 2.8)
- bug 718310 Port |bug 526998 – Implement F2 keyboard shortcut for renaming focused attachments when composing (on Windows and Unix)|

ToDo:
- bug 701714 Add support for DOM full-screen
- bug 640420 Add draggable splitter between urlbar and searchbar
- bug 711334 Be explicit that TLS version is 1.0
- look into
  - bug 698038 Update Preferences help for the new section to control crash report
  - bug 696757 Port “Time range to clear” from Firefox to SeaMonkey’s “Clear private data” dialog
- track
  - bug 687316 (Remaining) Sync changes to port to Suite

KaiRo

mcsmurf

Working on bug 721474 Port |bug 575830 Image zoom (Page zoom) is reset when I switch tabs| to SeaMonkey.

Misak

Mnyromyr

MReimer

Neil

Ratty

Page Info Fixes:

Fixed bug 168908 All columns in Page Info tabs can be hidden.
Fixed bug 723984 PageInfo->Permissions: Don’t assume that the whitelist pref is there. It defaults to true in the new add-ons manager code. Don’t assume all consumers use testPermission.
Fixed bug 724222 View page info -> Security: doesn’t show cookies were set for sites with ip:8080 address (see Firefox bug 409174).

Test Fixes:

bug 724331 TEST-UNEXPECTED-FAIL | chrome://mochitests/content/browser/suite/browser/test/browser_bug427559.js | an unexpected uncaught JS exception reported through window.onerror – executeSoon is not defined at …./suite/browser/test/browser_bug427559.js:56.
bug 724499 TEST-UNEXPECTED-FAIL | chrome://mochitests/content/browser/suite/browser/test/browser_pluginnotification.js | Test timed out.

Lightning/SeaMonkey Integration:

bug 719031 [Meta] SeaMonkey issues from Lightning bug 316916 landing (Task Quick Filter bar).
Fixed bug 721330 Make Customizing Lightning Toolbars work in SeaMonkey.
- Part 1: CalendarToolbar and TaskToolbar.
- Part 2: TaskActionsToolbar.
Waiting for review: bug 721327 Implement Tabs Toolbar for Thunderbird and Lightning Compatibility.

Backout Patches (waiting for comm-aurora approval):

bug 723970 Backout bug 698187 due to mozilla-central back out of parts of bug 698986 to resolve bug 716945.

Waiting for feedback:

bug 701432 Add support for fave icons on jump list uri entries.

ToDo:

Other:

Bug triage and Bug discussions.
End user support and PR in newsgroups and Mozillazine.

Ricardo

sgautherie

Fixed SeaMonkey (related) bugs:
- bug 707039 [SeaMonkey] mochitest-chrome: “TEST-UNEXPECTED-FAIL … textLTR.openPopup is not a function at … test_bug649840.xul:39″
- bug 714257 Package ‘necko_websocket.xpt’ in SeaMonkey after |Bug 640003 – WebSockets – upgrade to ietf-07|
- bug 716395 Port |Bug 716397 – [Linux] “Warning: package error or possible missing or unnecessary file: bin/libmozglue.so”| to SeaMonkey
- bug 718912 Port |Bug 717975 – only expose m-c implementation of navigator.mozApps on b2g| to SeaMonkey
- bug 719325 Package dom_network.xpt : Port Bug 677166 (Implement Network Status API) Part 2 Add .mozConnection to navigator
- bug 721357 Support ‘mailbloat’ test target in SeaMonkey
- bug 721533 [SeaMonkey] “Warning: package error or possible missing or unnecessary file: bin/components/chardet.xpt”
- bug 724448 tests cleanup for browser_367052.js and browser_bug431826.js, in SeaMonkey
Fixed Core bugs:
- bug 649840 RTL on forms inputs autocomplete
- bug 720095 SimpleTest/EventUtils.js: fix some strict warnings and nits
- bug 720952 [MacOSX] Some (or random?) builders report “Typelibs contain definitions of interface nsIDocCharset with different IIDs!” when “Linking .xpt files…”
- bug 720955 pyxpt: Report IIDs when they differ
- bug 722019 Investigate status of cbox-dis.gif (and related)
Fixed other projects bugs:
- [Firefox] bug 652297 Stop trying to package MSVC DLLs in debug Windows Firefox
- [Firefox] bug 721535 [Firefox] “Warning: package error or possible missing or unnecessary file: bin/components/chardet.xpt”

Stanimir

stefanh

Fixed:

bug 425916 Improve look of mac treerows when in editing mode.
bug 713445 [Mac Default] tabbrowser tab title text styling is wrong in Lion.
bug 713446 White text with text-shadow in selected bottom tabs.

Working on:

bug 721529 [Mac default] Reference to non-existing chrome://global/skin/tree/item.png in searchbar.css and directory.css.

tonymec

In progress: bug 716232 crash in JS GC at every cZ startup: working with dmandelin to find the culprit changeset
TODO: IRC meeting later today about giving up ownership of the Nightly Tester Tools extension to a fuller team from automation and/or QA

Any other business?

Need to review project areas
- IanN has put out a final draft of the project areas list, and will then confirm that anyone who is not in the loop already has been consulted.
- IanN is still waiting for the last few people to respond before creating the new version.
- We will also need to update the Mozilla-wide list of official reviewers
Extended Support Releases (ESR)
- At the moment looks like that will be based off Gecko 10 so that will be 2.7 for us. Assuming we have the machines, we will also have an ESR which might help move some of those still on 2.0 up to 2.7. We’re unlikely to move to ESR until Gecko 10.0.1 or 10.0.2.
- Our ESR should use the same branch as Firefox ESR so any Security and Stability “extended” fixes for Gecko will be picked up by the SeaMonkey ESR.
- An ESR (Extended Security Release) may not be a given for us out of the gate. Callek thinks we should revisit that, separately, once it is clearer what MoCo’s general plans for their marketing/target/support levels etc. are.
- mcsmurf is on the ESR mailing list is our ESR goto guy.
Geolocation
- Geolocation now works out of the box. MoCo turned it on by default for all applications that build off mozilla-central.
- For comm-beta all we need to do is (bug 494421) to add pref("geo.wifi.uri", "https://www.google.com/loc/json"); to browser-prefs.js. However we’re not even sure we are legally allowed to ship with the URL in, we might need to actually put in a pref to disable that in newer builds.

Retrieved from “https://wiki.mozilla.org/SeaMonkey/StatusMeetings/2012-02-07“

Meeting Notes from the Mozilla community: Mozilla Platform Meeting Minutes: 2012-02-07

Jesper Kristensen — Wed, 08 Feb 2012 04:00:05 +0000

Platform/2012-02-07

< Platform

« previous week | index | next week »

Platform Meeting Details

Tuesdays – 11:00 am Pacific
Dial-in: conference# 95312
- US/International: +1 650 903 0800 x92 Conf# 95312
- US toll free: +1 800 707 2533 (pin 369) Conf# 95312
- Canada: +1 416 848 3114 x92 Conf# 95312
Warp Core Vidyo Room
join irc.mozilla.org #planning for back channel

Notices / Schedule

Firefox Development

As mentioned last week, New Tab is now on by default. Tim Taubert is on a tear fixing followup issues, improving performance of the thumbnail service, and making styling tweaks.
Inline autocomplete has been disabled on trunk while we fix some additional issues that popped up (bug 720792). Marco is on the case, and we’ll get that re-enabled shortly.
Chemspill candidates for FF10 are being discussed at today’s channel meeting (2PM PT in Warp Core)

Firefox Developer Tools

Initial Debugger Has Landed
- Preffed off: to enable, set devtools.debugger.enable to true.

Performance

Telemetry dashboard is now public! See Taras’ presentation for access details.
Performance work week summary from Jared.
- Front-end activities and notes
Safebrowsing move from SQLite to flat file landed (bug 673470)
Various front-end telemetry probes landed, and a bunch more are in-progress.
- Notes from perf work-week
- page thumbnails for new-tab (bug 721019)
- site identity popup (bug 723090)
- Places idle frecency updates (bug 723124)
- Places idle maintenance tasks (bug 723126)
- Firefox menu opening time (bug 723515)

GFX

JS

Layout

Edwin Flores (intern) making good progress on “embedded SVG glyphs in OpenType fonts” (aka “SVG Fonts Done Right”) bug 719286. We should have something shippable-but-preffed-off-by-default soon.
Other notable patches:
- bug 721068 Graphite font shaping update from SIL
- bug 722322 Have the “1″ and “2″ keys switch between images in reftest-analyzer.xhtml
- bug 722071 Implement array style indexing for SVGStringList
- bug 714839 nsCSSFrameConstructor now inherits nsFrameManager

Video

libcubeb landed for Windows, but was disabled due to some random test failures
- Matthew working on reenabling that, plus tracking down failures in Mac and ALSA backends
WebRTC:
- alder repo now builds on Win32 (thanks Ted!).
- Win32, Linux and Mac can capture images from video with fabrice’s bug 629955 patches
- Chrome is now shipping Canary Chromium builds with a very early version of WebRTC enable-able. A number of 3rd-parties have built early demos based on it; several were shown at IETF Interim last week.
- Data channel API/protocols firming up; will evangelize at HTML5 Gaming work week in Toronto (great for games!) and look to implement ASAP

DOM

WebAPI

Started work on WebNFC
Mounir is editor for Network Information API and Screen Orientation APIs at W3C

Network

Identity

Plugins

Mobile

Accessibility

Tree Management

Security

No security reviews this week due to security work week in Santa Cruz.
Please work with Curtis to schedule reviews and
Update feature pages so we have accurate information

Stability Report

Socorro

Desktop

Firefox 10 Top Issues

Noticed increase in cycle collector crashes – GCGraphBuilder::NoteXPCOMChild(nsISupports*) – #2 crash
- bug 724129 – startup crash nsXBLDocumentInfo::cycleCollection::Traverse
- bug 724284 – Security bug we believe is causing the above regression.
- bug 718284 – Bug in FF11 that is also causing an increase of these crashes.
Startup crash @ PR_EnumerateAddrInfo | nsDNSRecord::GetNextAddr – #3 crash
- bug 718389 – Spike we saw in FF10b4
- No clear next steps for investigation. Correlation reports have been inconclusive.
bug 725009 – crash je_free | mozutils.dll. May be related to Flash.

Firefox 11 Top Issues

Increase in hangs – bug 722394
- bug 709209 – This is complicating our investigation.
- Marcia logging some plugin side reports that might help uncover the issue – bug 724617
- Top concern, not making much headway – need some developer help with the analysis.
bug 715401 – new on 11a2 but rising in b1 – trying to isolate the regression range.
bug 718284 – Separate issue causing increase in cycle collector issues.

Firefox 12 Top Issues

Nothing new and notable on Aurora yet.

Trunk Top Issues

Tracking a number of new crashes related to the landing of some plugin work bug 90268
- https://etherpad.mozilla.org/Bug-90268

Mobile

Socorro fixes to separate out Java signatures – fix went out last week.
- bug 719943- new field in json metadata needs exposure in the UI
Crash volume going down after a bunch of fixes landed last week.

Trunk Top Issues

Still lots of new stuff landing. Focus on logging all the new Java signatures…
top crash fixed – bug 723550 – Lots of base64 decode errors in logcat
bug 724215 – java.lang.NullPointerException: at org.mozilla.gecko.GeckoEvent.addMotionPoint(GeckoEvent.java)
bug 723495 – java.lang.IllegalArgumentException: View not attached to window manager at android.view.WindowManagerImpl.findViewLocked(WindowManagerImpl.java) – (affects 13, 12, 11)

Aurora Top Issues

bug 711852 – Crash in neon_composite_over_8888_8888 or neon_composite_over_n_8_0565 or fast_composite_over_8888_0565 or arm_neon_fill @ libxul.so@0xa – (affects 12, 11)

Beta

Not enough data yet – top issue is just 4 crashes
bug 719741 – Crash @ __libc_android_abort | dlfree | free | fclose

Roundtable

Retrieved from “https://wiki.mozilla.org/Platform/2012-02-07“

Brian R. Bondy: Snappy optimizations for faster Firefox startup

Wed, 08 Feb 2012 03:48:21 +0000

Snappy is a project that ~~aims to improve~~ is improving Firefox responsiveness. As part of this project I've been working on Firefox startup optimizations.

You can spend days, months, or even years trying to optimize code, but if you don't understand where to optimize, you won't be making a difference. Likewise, searching for an optimizations in a competitor's product is usually not the best way to get results.

It's nearly impossible to optimize code by guessing what is slow, you need to profile the code to understand the problems. Once you understand the problems you can then fix them, and then finally test to make sure they are fixed.

Here are some initial Firefox startup optimizations I've done with some lite profiling on Windows over the period of a few days:

bug 724177 - 30-50ms (5%) Firefox startup speed optimization on Windows in nsLocalFileWin
bug 724256 - Optimize move file calls on Windows, saving about 2ms per call (1 call on startup)
bug 722225 - Firefox startup speed by ~5% (-70ms) on Windows by optimizing D3D10CreateDevice1
bug 722315 - Firefox startup speed by by ~5% (-76ms) on Windows by lazy loading CLSID_DragDropHelper
bug 724203 - Optimize nsLocalFile::IsDirectory on Windows by 50% giving 5ms startup improvement
bug 724207 - Save 15-20ms on startup from unused file attributes fetch when opening files
bug 692255 - Find a way to get rid of prefetch files on Windows for faster startup

I plan to keep doing more startup optimizations for a while in between silent update work.

So how are optimizations found? There are many ways, the first I will talk about is Xperf.

Xperf

One way to identify optimization bottlenecks on Windows is to use Xperf. Xperf is a great way to find both IO bottlenecks and CPU usage bottlenecks.

It can tell you which files use the most IO, what the IO patterns are, which functions take the most time, and allow you to group based on different criteria to view the data in different ways. It is the tool that made Windows 7 so much faster than Windows Vista. It actually does a ton more than that but I won't focus on it in the context of this blog post.

Built in Mozilla profiler

Another way to find optimizations is to use Benoit's profiler (SPS). Currently it works well on Mac, and Windows is nearly completed.

I'm very excited to start using it on Windows.
It far surpasses the tools I've been using to find the bugs and fixes above.

Custom profiler

I haven't seen how the Mozilla built-in profiler is implemented, but I suspect that this custom profiler is a simplified version of the Mozilla profiler's Pseudostack mode.

I was able to find all of the above optimizations (with the exception of the prefetch task) with a tiny class with a couple of wrapper macros.

Basically the class is an RAII class built around the Win32 API QueryPerformanceCounter and QueryPerformanceFrequency. These functions allow you to get very detailed timing results.

For any function you want to profile you simply add the PROFILE_FUNCTION() macro to the start of the function. I usually start by adding this to each non-trivial function in a file.

Once you've found a function that takes a non trivial amount of time you can start to dig deeper into other functions inside of the function until you find the root cause.

But sometimes a function has a lot of code and you aren't sure what the slow part of the function is. For this I use a second macro PROFILE_STR("FunctionName:N") where N is a number I increment evenly spaced out. The string can be anything, I just use that normally.

These macros just create an object. The constructor of the object stores the start time, the destructor of the object gets the end time.

The destructor also uses the function name or string as a lookup in a global map that keeps track of the number of hits, the maximum length of time, the minimum length of time, and the average length of time for each function/string.

There is a third macro I was using to dump the results to a file at particular events I wanted to focus on, like first paint, or when the session is restored.

One thing you have to look out for with this method is if you happen to put the calls in a recursive function. In that case it will appear to be a bigger bottleneck because the first call will include the full length of time of all calls that contain it.
All of the inner calls will add onto that.

The output of this function is made when the third macro to dump the results is called. It dumps the results to a simple formatted .txt file:

Verifying startup results

If you're working on Firefox, a good way to verify that your speed optimization made a difference is to use the about:startup extension.

This extension times the startup of important events like firstPaint and sessionRestored and gives you the average up top.

To verify my results I just did 20 startups in sequence with a release build that contained my patches vs a release build that did not contain my patches.

Here is an example after one of the patches above:

Mozilla Add-ons Blog: Jetpack Project: weekly update for February 7th, 2012

wbamberg — Wed, 08 Feb 2012 01:59:20 +0000

Project News

We released a hotfix release, 1.4.3. It fixes an important regression in 1.4, 1.4.1 and 1.4.2 and should be taken by anybody currently using one of those releases. More details here.
FOSDEM happened, there were Jetpack presentations and discussions. Henrik Skupin blogged about it, and contributed a patch.
Andrew Sutherland has written an add-on using the SDK to break down Firefox memory usage by tab: or, to “help you lay blame more easily”

Quick Stats

Total open bugs: 253
Bugs created last week: 20
Bugs fixed last week: 12
Total SDK-based Addons on AMO: 432
Open pull requests on Github: 25

Note: the stats above are based on the queries I linked to for each item. If you have suggestions on how these queries might be made more accurate,please comment below. Stats generated at 2012-02-07 17:43:52 PST

Meeting Brief

The Add-on Builder is preparing for its 1.0 release. We have one blocker, bug 724766, otherwise things are looking good.
We had a brief 1.4.3 postmortem: concluded that we need to improve test coverage for beta releases.
There’s a lot of demand to make the SDK support Thunderbird. The SDK team does not have the resources to support Thunderbird officially, but should not prevent Thunderbird from working by, for example, throwing an exception when Thunderbird is detected.
Here’s a blog post from Dietrich on using the SDK to deliver features into Firefox.

Full minutes are available here:

https://wiki.mozilla.org/Jetpack/Weekly_Meeting/2012-2-7#Minutes

Nicholas Nethercote: The benefits of reducing memory consumption

Nicholas Nethercote — Wed, 08 Feb 2012 01:22:40 +0000

TL;DR: Any single change that reduces Firefox’s memory consumption can affect Firefox’s speed, stability and reputation in a variety of ways, some of which are non-obvious. Some examples illustrate this.

The MemShrink wiki page starts with the following text.

MemShrink is a project that aims to reduce Firefox’s memory consumption. There are three potential benefits. Speed. [...] Stability. [...] Reputation.”

I want to dig more deeply into these benefits and the question of what it means to “reduce Firefox’s memory consumption”, because there are some subtleties involved. In what follows I will use the term “MemShrink optimization” to refer to any change that reduces Firefox’s memory consumption.

Speed

People tend to associate low memory consumption with speed. However, time/space trade-offs abound in programming, and an explicit goal of MemShrink is to not slow Firefox down — the wiki page says:

Changes that reduce memory consumption but make Firefox slower are not desirable.

There are several ways that MemShrink optimizations can improve performance.

Paging

The case that people probably think of first is paging. If physical memory fills up and the machine needs to start paging, i.e. evicting virtual memory pages to disk space, it can be catastrophic for performance. This is because disk accesses are many thousands of times slower than RAM accesses.

However, some MemShrink optimizations are far more likely to affect paging than others. The key idea here is that of the working set size — what’s important is not the total amount of physical or virtual memory being used, but the fraction of that memory that is touched frequently. For example, consider two programs that allocate and use a 1GB array. The first one touches pages within the array at random. The second one touches every page once and then touches the first page many times. The second program will obviously page much less than the first if the system’s physical memory fills up.

The consequence of this is that a change that reduces the size of data structures that are accessed frequently is much more likely to reduce paging than a change that reduces the size of data structures that are accessed rarely. Note that this is counter-intuitive! It’s natural to want to optimize data structures that are wasteful of space, but “wasteful of space” often means “hardly touched” and so such optimizations don’t have much effect on paging.

Measuring the working set size of a complex program like a web browser is actually rather difficult, which means that gauging the impact of a change on paging is also difficult. Julian Seward’s virtual memory profiler offers one possible way. Another complication is that results vary greatly between machines. If you are running Firefox on a machine with 16GB of RAM, it’s likely that no change will affect paging, because Firefox is probably never paging in the first place. If you are on a netbook with 1GB of RAM, the story is obviously different. Also, the effects can vary between different operating systems.

Cache pressure

Some MemShrink optimizations can also reduce cache pressure. For example, a change that makes a struct smaller would allow more of them to fit into a cache line. Like paging, these effects are very difficult to quantify, and changes that affect hot structures are more likely to reduce cache pressure significantly and improve performance.

Structure traversals

Sometimes large data structures must be traversed, and reducing the number of elements in the data structure can reduce that traversal time. The obvious case for Firefox is the JavaScript heap — the garbage collector and cycle collector frequently traverse it, and so any change that causes dead objects to accumulate more slowly will reduce their traversal times.

Only a small fraction of MemShrink optimizations will speed up structure traversals.

Stability

If Firefox (or any program) uses too much memory, it can lead to aborts and crashes. These are sometimes called “OOMs” (out of memory). There are two main kinds of OOM: those involving virtual memory, and those involving physical memory.

Virtual OOMs

A “virtual OOM” occurs when the virtual address space fills up and Firefox simply cannot refer to any more memory. This is mostly a problem on Windows, where Firefox is distributed as a 32-bit application, and so it can only address 2GB or 4GB of memory (the addressable amount depends on the OS configuration). This is true even if you have more than 4GB of RAM. In contrast, Mac OS X and Linux builds of Firefox are 64-bit and so virtual memory exhaustion is essentially impossible because the address space is massively larger.

(I don’t want to get distracted by the question of why Firefox is a 32-bit application on Windows. I’ll just mention that (a) many Windows users are still running 32-bit versions of Windows that cannot run 64-bit applications, and (b) Mozilla does 64-bit Windows builds for testing purposes. Detailed discussions of the pros and cons of 64-bit builds can be read here and here.)

The vast majority of MemShrink optimizations will reduce the amount of virtual memory consumed. (The only counter-examples I can think of involve deliberately evicting pages from physical memory. E.g. see the example of the GC decommitting change discussed below.) And any such change will obviously reduce the number of virtual OOMs. Furthermore, the effect of any reduction is obvious and straightforward — a change that reduces the virtual memory consumption by 100MB on a particular machine and workload is twice as good as one that reduces it by 50MB. Of course, any improvement will only be noticed by those who experience virtual OOMs, which typically is people who have 100s of tabs open at once. (It may come as a surprise, but some people have that many tabs open regularly.)

Physical OOMs

A “physical OOM” occurs when physical memory (and any additional backing storage such as swap space on disk) fills up. This is mostly a problem on low-end devices such as smartphones and netbooks, which typically have small amounts of RAM and may not have any swap space.

The situation for physical memory is similar to that for virtual memory: almost any MemShrink optimization will reduce Firefox’s physical memory consumption. (One exception is that it’s possible for a memory allocation to consume virtual memory but not physical memory if it’s never accessed; more about this in the examples section below.) And any reduction in physical memory consumption will in turn reduce the number of physical OOMs. Finally, the effects are again obvious and straightforward — a 100MB reduction is twice as good as a 50MB reduction.

Reputation

Finally, we have reputation. The obvious effect here is that if MemShrink optimizations cause Firefox to become faster and more stable over time, people’s opinion of Firefox will rise, either because their own experience improves, or they hear that other people’s experience improves.

But I want to highlight a less obvious aspect of reputation. People often gauge Firefox’s memory consumption by looking at a utility such as the Task Manager (on Windows) or ‘top’ (on Mac/Linux). Interpreting the numbers from these utilities is rather difficult — there are multiple metrics and all sorts of subtleties involved. (See this Stack Overflow post for evidence of the complexities and how easy it is to get things wrong.) In fact, in my opinion, the subtleties are so great that people should almost never look at these numbers and instead focus on metrics that are influenced by memory consumption but which they can observe directly as users, i.e. speed and crash rate… but that’s a discussion for another time.

Nonetheless, a non-trivial number of people judge Firefox on this metric. Imagine a change that caused Firefox’s numbers in these utilities to drop but had no other observable effect. (Such a change may be impossible in practice, but that doesn’t matter in this thought experiment.) One thing that has consistently surprised me is that some people view memory consumption as something approaching a moral issue: low memory consumption is virtuous and high memory consumption is sinful. As a result, this hypothetical change would improve Firefox’s reputation, rightly or wrongly, for the better.

Let’s call this aspect of Firefox’s reputation the “reputation-by-measurement”. I suspect the most important metric for reputation-by-measurement is the “private bytes” reported by the Windows Task Manager, because that’s what people seem to most often look at. Private bytes measures the virtual memory of a process that is not shared with any other process. It’s my educated guess that in Firefox’s case that the amount of shared memory isn’t that high, and so the situation is similar to virtual OOMs above — just about any change that reduces the amount of virtual memory will reduce the private bytes by the same amount, and in terms of reputation-by-measurement, a 100MB reduction is twice as good as a 50MB reduction.

Examples

Some examples help bring this discussion together. Consider bug 609905, which removed a 512KB block of memory that was found to be allocated but never accessed. (This occurred because some code that used that block was removed but the allocation wasn’t removed at the same time.) What were the benefits of this change?

The 512KB never would have been in the working set, so performance would not have been affected.
Virtual memory consumption would have dropped by 512KB, slightly reducing the likelihood of virtual OOMs.
Physical memory consumption probably didn’t change — because the block was never accessed, it probably never made it into physical memory.
Private bytes would have dropped by 512KB, slightly improving reputation-by-measurement.

Now consider bug 670596, which made the JavaScript garbage collector decommit (i.e. remove from physical memory and backing storage) 1MB heap chunks that are unused. What were the benefits of this change?

Performance may have improved slightly due to reduced paging, on machines where paging happens. Those chunks are clearly not in the working set when they are decommitted, but if paging occurs, the pre-emptive removal of some pages from physical memory may prevent the OS from having to evict some other pages, some of which might have been in the working set.
Virtual memory consumption would not have changed at all, because decommitted memory still takes up address space.
Physical memory consumption would have dropped by the full decommit amount — 10s or even 100s of MBs in many cases when decommitting is triggered — significantly reducing the likelihood of physical OOMs.
Private bytes would not have changed, leaving reputation-by-measurement unaffected. [Update: Justin Lebar queried this. This page indicates that decommitting memory does reduce private bytes, which means that this change would have improved reputation-by-measurement.]

Another interesting one is bug 676457. It fixed a problem where PLArenaPool was requesting lots of allocations of ~4,128 bytes. jemalloc rounded these requests up to 8,192 bytes, so almost 50% of each 8,192 byte block was wasted, and there could be many of these blocks. The patch fixed this by reducing the requests to 4,096 bytes which is a power-of-two and not rounded up (and also usually the size of an OS virtual memory page). What were the benefits of this change?

Performance may have improved due to less paging, because the working set size may have dropped. The size of the effect depends how often the final 32 used bytes of each chunk — those that spilled onto a second page — are accessed. For at least some of the blocks those 32 bytes would never be touched.
Virtual memory consumption dropped significantly, reducing the likelihood of virtual OOMs.
Physical memory consumption may have dropped, but it’s not clear by how much. In cases where the extra 32 bytes are never accessed, the second page might not have ever taken up physical memory.
Private bytes would have dropped by the same amount as virtual memory, improving reputation-by-measurement.

Finally, let’s think about a compacting, generational garbage collector, something that is being worked on by the JS team at the moment.

Performance improves for three reasons. First, paging is reduced because of the generational behaviour: much of the JS engine activity occurs in the nursery, which is small; in other words, the memory activity is concentrated within a smaller part of the working set. Second, paging is further reduced because of the compaction: this reduces fragmentation within pages in the tenured heap, reducing the total working set size. Third, the tenured heap grows more slowly because of the generational behaviour: many objects are collected earlier (in the nursery) than they would be with a non-generational collector, which means that structure traversals done by the garbage collector (during full-heap collections) and cycle collector are faster.
Virtual memory consumption drops in two ways. First, the compaction minimizes waste due to fragmentation. Second, the heap grows more slowly.
Physical memory consumption drops for the same two reasons.
Private bytes also drops for the same two reasons.

A virtuous change indeed.

Conclusion

Reducing Firefox’s memory consumption is a good thing, and it has the following benefits.

It can improve speed, due to less paging, fewer cache misses, and faster structure traversals. These changes are likely to be noticed more by users on lower-end machines.
It improves stability by reducing virtual OOM aborts, which mostly helps heavy tab users on Windows. It also improves stability by reducing physical OOM aborts, which mostly affects heavy-ish tab users on small devices like smartphones and netbooks.
It improves reputation among those whose browsing experience is improved by the above changes, and also among users who make judgments according to memory measurements with utilities like the Windows Task Manager.

Furthermore, when discussing MemShrink optimizations, it’s a good idea to describe improvements in these terms. For example, instead of saying “this change reduces memory consumption”, one could say “this change reduces physical and virtual memory consumption and may reduce paging”. I will endeavour to do this myself from now on.

Robert Accettura: Why Open Source Is Pretty Awesome

Robert — Wed, 08 Feb 2012 01:01:09 +0000

At some point I think it’s easy to take things for granted. Being able to alter software to meet your needs is an awesome power.

Today, a tweet rehashed an annoyance regarding a tactic on websites to alter copy/paste and put a link with tracking code in your clipboard. I could opt out, but that doesn’t fix when websites roll their own. It’s a fairly simple thing to implement. In my mind there’s little (read: no) legitimate justification for oncopy, oncut or onpaste events.

So I did an hg pull while working on some other stuff. I came back and wrote a quick patch, started compiling and went back to working on other stuff.

Then came back to a shiny new Firefox build with a shiny new preference that disabled the offending functionality. A quick test against a few websites shows it works as I intended by simply killing that event. You can’t do these things with closed source.

Of course I found the relevant bug and added a patch for anyone interested.

A 15 minute diversion and my web browsing experience got a little better. Sometimes I forget I’ve got experience on that side of the wire too .

Harvey Anderson: Comments supporting DMCA jailbreaking exemption

lockshot — Wed, 08 Feb 2012 00:55:57 +0000

Every three years the US Copyright office, examines whether it will renew certain exemptions to the DMCA. In 2009 we submitted arguments supporting the EFF’s petition for the exemption of jailbreaking from the DMCA. The Copyright office granted the exemption in 2010 which now expires at the end of 2012.

Although it seems a bit silly to have to do this every three years, we’re going to again file a brief supporting the exemption for jailbreaking, also known as “rooting.” EFF has more information here on the arguments and the process.

Based on feedback from developers around the Mozilla project, the brief will contend that rooting is important because it’s necessary to achieve competitive application performance on Android mobile platforms, to effectively debug applications, and for regression testing. In addition, it’s even more critical now as mobile devices surpass desktop, and Internet access increasingly comes from mobile platforms.

We plan to file our comments on Friday afternoon. If you have ideas or thoughts that could be incorporated in the brief, please let us know. Alternatively, you can file your own comments, or if your flavor is petitions go here.

Taras Glek: Snappy, Feb 2nd – FOSDEM, Help Wanted

tglek — Wed, 08 Feb 2012 00:52:06 +0000

We cancelled last week’s snappy meeting due to Perf/Snappy workweek + FOSDEM. See Jared’s post for a summary of the workweek, I’ll mention the rest below.

We figured out a strategy for avoiding blocking DOM Storage IO (use scriptblocker to async preload relevant dom storage. Do async writeback to commit). We have a plan for cancellable SQL queries, bug 722243.

SetTimeouts/30s telemetry landed in bug 715953, I attached result of that in bug 715376. Persistent telemetry was backed out while Nathan investigates problems, bug 707320.

Brian Bondy has been fixing our usage of Windows APIs:

bug 722225 - Firefox startup opt on Windows by optimizing D3D10CreateDevice1 (pending review)
bug 722315 - Firefox startup opt on Windows by lazy loading CLSID_DragDropHelper (landed)
bug 692255 - Find a way to get rid of prefetch files on Windows for faster startup (pending review)

We spent the weekend at FOSDEM. I re-presented my Plumbers talk on why Linux sucks for starting big apps. I also did a Telemetry talk. The audience was great.

Help Wanted

To my great regret, I forgot to mention that Mozilla is hiring in my talks. In particular, I’m looking for more performance hackers. If enjoy spending quality time with stack traces,writing profilers or analyzing performance logs leave a comment or send me an email. Compiler toolchain and/or kernel hacking experience would be a great bonus.

Blog of Metrics: Some Results for Memshrink

Saptarshi Guha — Wed, 08 Feb 2012 00:38:13 +0000

As the website ( https://wiki.mozilla.org/Performance/MemShrink ) describes, MemShrink is a project to reduce Firefox memory consumption. Summary (taken from the webpage) is

Speed. Firefox will be faster due to less cache pressure, less paging, and fewer/smaller GC and CC pauses. Changes that reduce memory consumption but make Firefox slower are not desirable.
Stability. Firefox will suffer fewer aborts/crashes due to virtual or physical memory exhaustion. The former is mostly a problem on 32-bit Windows builds with a 2GB or 4GB virtual memory limit, the latter is mostly a problem on mobile devices that lack swap space.

The engineers working on MemShrink asked the Metrics team to help discover and quantify what variables affect variables that related to MemShrink. Key among these is RESIDENT_MEMORY which is the resident memory that Firefox occupies. For a given installation, multiple measurements are taken before the data is submitted. The data, for a given installation, is recorded as a histogram (so we dont have serial correlations between observations …), and the final value used in modeling is the weighted mean.

The Data Set

We already have some variables at our disposal, them being

version :: the version of Firefox (10,11 or 12)
number of addons
does the installation have Firebug? (Yes/No)
memory size
Number of CPUs
RESIDENT_MEMORY

The data set was a 70% sample taken from the Hbase Telemetry table from 2012-01-01 to 2012-01-31. With those variables, we first looked at QQ Plots ( see http://en.wikipedia.org/wiki/Q-Q_plot ) to see the distribution for variable transformations (e.g. truncation? log transformation?). After that, the sample was further randomly sampled 1000 12.5% samples of the 70% sample. ANOVA was run across each of these samples and the quantiles of the residuals, the parameters and adjusted R squareds were taken.

Results

The following diagrams are scatter plots of some of the covariates vs. RESIDENT_MEMORY. This is used to consider interactions or transformations.

In the following graphs, Y vs X implies Y on the vertical axis and X on the horizontal. ‘log(A,2)’ is the log of A with respect to base 2.

1a). log(RESIDENT_MEMORY in bytes,2) vs. Log(# of Addons,2) by Version

1b) log(RESIDENT_MEMORY in bytes ,2) vs. Log(Memsize in bytes,2) by Version

1c) log(RESIDENT_MEMORY bytes,2) vs. HasFireBug by Version

1d) Quantiles of log(Resident Memory bytes,2) by Version

Note, there doesn’t seem to be interaction with version except for a feeble one in (1c)
1d) is also called the Empirical Cumulative Distribution Function.. If the distribution were uniform, it would be a diagonal at 45 degrees. The panel for ’12′ indicates that 60% of the obs. are less than 2^18 bytes .
In summary, he data set is extremely noisy. Though the assumptions of modeling are met (independence etc)
the variables only explain 35% of the variation (not even 50) as seen from the ANOVA R^2.s
1a) definite increasing trend with log(addon+1) but there is so much variation! and no difference across versions.
1b) same as (2) except that in 12 the flattening happens earlier though flattens at a higher value than 10,11. I expect some flattening to happen, why would RESIDENT_MEMORY increase continuously just because memory size is bigger?
1c) – marginal difference, but again so much noise.
1d) the distribution of RESIDENT_MEMORY is almost same for 10,11,12 with a slight upward shift for 12.

We cannot expect a great fit with these variables. The next is a panel display of QQ plots of 100 random ANOVA residuals. Statistical inference in in this particular case study requires that the residuals be Gaussian distributed. Here ‘normal’ means the Normal distribution. They aren’t perfectly Normal, but the departure looks acceptable. Not included are the other displays such Scale-Location plots, though upon inspection they show no relation between scale and location (i.e. variances does not depend on mean).

QQ Plots for Residuals for a Random 25

Interpretation

Averaging the coefficients of 1000 regression produces the following parameter table. Though the estimates are precise the R squared itself is not the highest – a lot of explanation is required. Explanation of the table follows below it. The model is log(RESIDENT_MEMORY,2) ~ version + log(addon+1,2) + hasFirebug(fb) + log(memorysize,2) .

The first column of numbers is the left end of the 95% confidence interval of the coefficient, and the 3rd column is the upper end of the 95% CI.

                          2.5    mean coef     97.5
(Intercept)       13.85290273 13.89114640 13.92939007
version11         -0.02897665 -0.01986893 -0.01076121
version12          0.09062749  0.10488013  0.11913277
log(addon + 1, 2)  0.28370203  0.28668868  0.28967534
fbTRUE             0.08945122  0.11898676  0.14852230
log(cpu, 2)        0.06480277  0.06965200  0.07450124
memsize            0.23214017  0.23590406  0.23966795

What this means is that, (‘keeping everything else fixed’)

version 11 reduces memory consumption about 2% (on average, but keep in mind there is a lot of variation) over v.10
version 12 ups it by about 11% over v.10 (see the distribution at top of log of RESIDENT_MEMORY by version)
Presence of Firebug extension causes a slight increase (on average of 12%)
if one doubles the number of addons (and add 1 to this) the RESIDENT_MEMORY increases ~ by 33%

Future:

The thing with large data is that even the smallest difference can be called ‘significant’. What is true that 12 seems to use more memory. And that the difference between using Firebug or not decreases for 12. But equally importantly the collection of variables explains only 36% of the variance – so though the estimates are precise, there is a lot of variance around any estimate. Results should be taken with caution.

All the computation and analysis was done using RHIPE (see https://github.com/saptarshiguha/RHIPE ). We have only covered some variables we thought might affect RESIDENT_MEMORY. There are however 215 variables captured by the Telemetry project and we could well benefit doing some tree-based analysis (randomforests anyone?) to discover useful variables (that affect RESIDENT_MEMORY). More on this later.

Sample RHIPE Code

This is the code producing marginal plots.

yy <- function(location,var,N=3){
  m <- ewrap({
    Var <- unserialize(charToRaw(Sys.getenv("varname")))
    N <- unserialize(charToRaw(Sys.getenv("N")))
    r <- r[!is.na(r$memres) & !is.na(r$memsize) & r$memres>-Inf & r$memsize>-Inf,]
    Y <- r[,"memres"];X <- r[,Var]; V <- as.character(r[,"version"])
    for(i in 1:nrow(r)){
      rhcollect(list(version=V[i],var=X[i],value=round(Y[i],N)), 1)
    }})
  mapred <- list(varname=rawToChar(serialize(var,NULL,ascii=TRUE)),
                 N=rawToChar(serialize(N,NULL,ascii=TRUE)))
  reduce <- summer
  z <- rhmr2(m,reduce=reduce, combine=TRUE
           ,ifo="/user/sguha/telemetry/samples/1/p*",of=location
           ,mapred=mapred)
  rhstatus(rhex(z,async=TRUE),mon.sec=5)
  z <- rhread(sprintf("%s/p*",location))
  library(Hmisc)
  version <- unlist(lapply(z,function(r) r[[1]][[1]]))
  varble <- unlist(lapply(z,function(r) r[[1]][[2]]))
  value <- unlist(lapply(z,function(r) r[[1]][[3]]))
  count <- unlist(lapply(z,function(r) r[[2]][[1]]))
  z1 <- data.frame(version=version,var=varble,value=value, count=count,
                   stringsAsFactors=FALSE)
  colnames(z1) <- c("version",var,"value","count")
  z1 <- z1[order(z1$version,z1[,var],z1$value),]
  z2 <- do.call('rbind',lapply(split(z1,list(z1$version,z1[,var])),function(r){
    P <- 1:19/20
    data.frame(version=r[1,"version"],var=r[1,var], p=P, q= wtd.quantile(r$value,r$count, P),stringsAsFactors=FALSE)
  }))
  colnames(z2) <- c("version",var,"p","q")
  z2
}

library(lattice)
library(latticeExtra)

###############################
## Plot of memres vs addons
###############################
addons <- yy("/user/sguha/telemetry/tmp/b","addon")
pdf("~/addons.pdf")
asTheEconomist(
              xyplot(q~log(addon,2)|version, type='p',
              main='Quantiles of Log(RESIDENT_MEMORY,2) vs. Log(addon,2)'
                     ,data=addons,pch=1, cex=0.3,col='#00000030'
                     ,layout=c(3,1),aspect=1,ylab='Log(RESIDENT_MEMORY,2)'
                     ,panel=function(x,y,subscripts,...){
                       panel.grid(h=-1,v=-1,lwd=0.5)
                       panel.xyplot(x,y,...)
                       panel.loess(x,y,col='red',lwd=0.7,type='l')
                     })
               ,type='p',pch=16, cex=0.7,col='#00000060')
dev.off() ##cut at 6
#############################

Sean McArthur: Chrome for Android

Tue, 07 Feb 2012 23:28:35 +0000

Chrome for Android:

Exciting news for Android. It’s always been a wonder why the stock Browser wasn’t Chrome, and now it is. And it really rocks. The tab interface is fun to use.

However, since it uses an updated version of the webkit rendering engine, it should need to load that library upon initialization. The standard engine is always in memory, something that’s held back Firefox for Android. Yet, Chrome doesn’t seem to suffer from this.

Perhaps the mobile Firefox engineers already know, but I can think of 3 possibilities:

There’s a way to keep the new libraries in memory.
There’s a way to replace the default engine
Or they just handle the loading in a better way.

Whichever it is, hopefully mobile Firefox can find a way to improve their loading to be close to equivalent to Chrome’s loading.

Mozilla Add-ons Blog: SF Meetup: Add-ons Made Easy with Builder and SDK

Amy Tsay — Tue, 07 Feb 2012 22:35:42 +0000

If you’re in the Bay Area, we invite you to join us at our San Francisco office on Tuesday, February 21, for an evening of food, drinks and good company!

Come and see how easy it is to create add-ons for Firefox with Add-on Builder and the Add-on SDK. If you’re a Web developer and know HTML, JavaScript and CSS, you already have what it takes to make great add-ons.

One lucky raffle winner will receive an Android tablet!

Date: Tuesday, February 21, 2012
Time: 6:00 – 8:00pm
Location: Mozilla SF – 2 Harrison Street, 7th Floor

** Reserve your spot now! **

David Boswell: Now we can say Mozilla is a world-wide community

davidwboswell — Tue, 07 Feb 2012 21:10:17 +0000

With the launch of Mozilla Antarctica today, we can truly say that Mozilla is a world-wide community. Check out the maps of local Mozilla communities around the world to see all of the cool stuff going on.

Now that we have all of the ground covered, we’ll need to reach out to the residents of the International Space Station to see if they’re interested in forming a local Mozilla community…

Ben Hearsum: Release Automation – Part 1: Bootstrap

bhearsum — Tue, 07 Feb 2012 20:14:25 +0000

One of the first tasks I had as a full-time employee of Mozilla was getting the Bootstrap Release framework working with Firefox 3.0 Beta releases. Now, just over 4 years later, our Release Automation has changed dramatically in many ways: primary language, supported platforms, scope and extent, reliability, and versatility. I thought it made be interesting to trace the path from there to here, and talk about what’s in store for the future, too. Throughout all of this work there’s been two overarching goals: 1) Lower the time it takes to go from “go to build” to “updates available for testing” – which we call “end2end time”, and 2) Remove the number of machines we have to log into, commands we have to run, and active time we have to spend on a release – known as “manual touchpoints”. I’ll be referencing these a lot throughout this series.

This post will talk about what I know of Bootstrap and my work porting it to Firefox 3.0.

In its earliest form Bootstrap was a simple scripted version of much of the previously manual release process. The processes for tagging VCS repositories, creating deliverables (source packages, en-US and localized builds, updates), and some verifications were encapsulated into its scripts. This was a big improvement over the 100% manual, cut+paste-from-a-wiki, process. Instead of logging into many machines and running many commands, the release engineer had to log in to many machines and run a few, very simple commands. The very first release that was Bootstrap-aided was Firefox 1.5.0.9, built on December 6th, 2006. This was before my time, but a former release engineer, Rob Helmer, told me that the end2end time back then could be multiple days, and countless touchpoints.

Over time, more parts of the release process were automated with Bootstrap, further reducing the burden on the release engineer. Even with these big improvements some classes of things were still not codified: which machines to run which commands on, when and in what order to run things, who to notify about what. Enter: Buildbot. Integrating Bootstrap into Buildbot was the next logical step in the process. It would handle scheduling and status, while Bootstrap would remain responsible for all of implementation. With this, the release engineer only had to log in to a few machines and run a few, very simple commands. Another big improvement! The first release to benefit from this was Firefox 2.0.0.8, built on October 10th, 2007. This work was largely done by Rob Helmer.

Around this time we were gearing up to start shipping the first Firefox 3.0 Beta release and had never tested Bootstrap against that development branch. I was tasked with making whatever changes were necessary to Bootstrap and our Buildbot to make it work. The Buildbot side was largely simple, because of it being at such a high abstraction layer, but back in these days we still had single purpose Buildbot masters, so it involved adding several hundred lines of config code.

The Bootstrap side was far more interesting. Until this point, there was a lot of built-in assumptions based on what the 1.8 branch looked like, including:

Releases are done from CVS branches (explicitly _not_ trunk)
Windows build machines run Cygwin
Linux packages are in .gz format
The crash reporting system Talkback is always shipped

By themselves, none of these things are too challenging to deal with, but as a very new hire, the combination took me about a month to find solutions to and fully test, with many rounds of feedback and guidance along the way. With all of that done and landed, we managed to use the new automation to build Firefox 3.0b2 on December 10, 2007. At this point, the end2end time was around 24h and there were about 20 manual touchpoints.

Over the next 8 months or so there were a few major improvements of note. Firstly, Nick Thomas fixed bug 409394 (Support for long version names) allowed us to start shipping releases with nicer looking filenames like “Firefox Setup 3.0 Beta 4″. Not a crucial thing, but much nicer from the user perspective. bug 422235 (enable fast patcher for release automation) was a massive improvement in update generation, written by schrep. With this work, we went from taking 6-8 hours to generate updates, down to ~1h — an incredible savings in time. Finally, bug 428063 (Support major releases & quit using rc in overloaded ways) (also fixed by Nick) enabled us to build RCs with Bootstrap. While it may sound simple, there’s a lot of things in release automation that depend on filename, and catching them all can be difficult. As well as making it possible to build these, this bug also renamed the internal “rc” notion to “build”, to avoid situations where we’d have things like “3.0 RC1 rc1″, which was utterly confusing.

So, in the early days there were tons of improvement quickly: Bootstrap itself sped things up and lowered the possibility of error through reducing manual touchpoints. Buildbot + Bootstrap did so again, through the same methods. We also had pure speed-ups through things such as fast patcher. Having these things allowed us to maintain the 2.0.0.x and 3.0.x branches more more easily, and get chemspill releases out quickly and simultaneously. All of this work had to be done incrementally too, because we had to continue shipping releases while the work was happening. It’s hard to find good data for releases done with this version of the automation, but I guesstimate that the end2end time was around 12-14 hours and the number of manual touchpoints was still around 20 for a release without major issues.

Next up….Release Automation on Mercurial, v1.

Boris Zbarsky: Vendor interactions with the CSS working group and product secrecy

bzbarsky — Tue, 07 Feb 2012 18:50:18 +0000

The minutes from yesterday's CSSWG face-to-face meeting are a very interesting read in all sorts of ways. I was somewhat struck by this part:

  tantek: I think if you're working on open standards, you should propose
          your features before you implement them and discuss that here.
  smfr: We can't do that.
  sylvaing: We can't do that either.

Those are the Apple and Microsoft representatives replying to Tantek.

Now I won't claim that Mozilla always does this, or that it's even always desirable; it's often better to have a prototype and then discuss the standard than discuss standardization in a completely theoretical way. But this is not about prototypes; this is about not being able to talk about a feature until there's a more or less complete implementation, which is when Microsoft and Apple tend to announce new features. I knew that both Microsoft and Apple had longstanding policies of refusing to discuss future plans, but hadn't really thought about the negative effect this blanket policy has on standardization efforts...

Crystal Beasley: How People Think Facebook Connect Log‑in and Log‑out Work

Crystal Beasley — Tue, 07 Feb 2012 17:59:17 +0000

As part of my work on the Identity project at Mozilla, I’ve been taking a look into how the average person thinks about single sign-on. It’s a complex system, so not surprisingly, it’s most often misunderstood at a fundamental level.

I ran an unmoderated user test with usertesting.com with five users. Their task was to go to Buyosphere, a site that implements Facebook Connect, create an account, then log out. Then I asked them a series of questions. All five indicated they had used Facebook to log into sites before.

“When you log out of Buyosphere, do you think it logs you out of Facebook also? Why or why not and how would you tell for sure?” Incorrect answers are red and bold.

User 1) “i believe that once i log out of buyosphere, i am also logged out of facebook. once i am logged out i cannot see any more information regarding my account after logging out.”
User 2) “I think it does log me out because it gave me connect with Facebook, thus it mean it is not recognizing that I have a Facebook account. I’d tell if I am or not by opening up Facebook in a new tab and seeing if it is automatically logged in or not.”
User 3) “No, I told facebook to remember me. I would open my facebook page in a different browser window? I don’t normally tell it to log me out, so that is only a guess.”
User 4) “Yes. I do not see a separate window for my facebook site so I would assume that Buyosphere would have set it up to log me out when I’m done on their site. I think I can check to see if I’m logged out by opening facebook and seeing if the login boxes come up or if it takes me straight to my FB page. I will try it right now….I was wrong it didn’t log me out. I am surprised by that. That makes the process of logging off take longer if I have to log out of this site and then go to FB to log out of that site separately.”
User 5) “I don’t think it would log me out. I have used other sites through facebook and usually the log in and log outs are separate. I can tell for sure by checking my facebook page which I just did and I am logged in.”

The goal of this research was to determine if users had a mental model that would allow them to correctly log out of a single sign-on system in places where there are security concerns like a shared computer or public terminal. The answer is no. Disclaimer: Do not be tempted to extrapolate that this means 60% of people would get this question wrong. This is qualitative research, not quantitative and should not be regarded as having statistical significance.

The last little gut-wrenching nugget comes from the last 20 seconds of one test. Watch and weep.

You caught it, right? She believes she could use her Facebook user and password to log into this site. *sigh* It’s horrifying how easily a bad actor could build a honeypot to collect Facebook credentials.

In addition to confusion over when/where/how to log-in and log-out, we know that sites have big percentages of users with multiple accounts. This video clearly illustrates how that can happen.

What are sites to do? I don’t think there is a good answer. As much as your business case allows, use only one identity provider. If you’re using Facebook Connect, don’t have a standard log-in. Too often, two log-in systems are less than the sum of their parts. LukeW’s article details experiments to mitigate these problems. Some of them have security concerns that wouldn’t fly with many sites. I’m not confident any of them work massively better than only supporting one way of logging in. However, many site will feel it necessary to have a standard log-in plus Facebook Connect. Clearly more thinking and testing needs to be done in this direction.

Of course, my biased view is that we can build better solutions for single sign-on.

How People *Think* Facebook Connect Log‑in and Log‑out Work is a post from: Crystal Beasley, UX Designer at Mozilla

Mitchell Baker: Resurfacing

mitchell — Tue, 07 Feb 2012 16:41:17 +0000

I’ve been sort of invisible online for a few weeks. Sunday night we finally got moved out of our old, beat-up house. By “beat-up” I mean foundation damage, and water and silt flowing into the downstairs rooms, making them uninhabitable. It’s a wreck, but it’s big. So we had a decade of stuff crammed into a zillion storage spaces. I though getting ourselves moved into the temporary living spot during remodeling was the big job, but then my husband started pulling stuff out from the truly hidden storage spots, and that took another week of evenings and weekends to finish up.

Now we’re living in a space about 1/3 the size, with tons of stuff in storage (do we even want it back)? and am back to the normal focus on Mozilla, online life, etc. Funny have the luxury of a stable life well above subsistence level leads to the accumulation of so much stuff that seems meaningful at first but then becomes a burden.

More shortly.

Breaking the egg: About Toggling Tabs on Top...

Tue, 07 Feb 2012 15:05:55 +0000

Tabs on top is scheduled to land in Thunderbird 11, and we’re pretty excited.

A few folks on Bugzilla have been wondering about how they can switch back to Tabs on Bottom, and have been shocked to find that such a toggle is missing. A bug was filed by a concerned user, asking us to put the toggle in. They were concerned that we were restricting customization and flexibility by not allowing them to change the tabs UI.

However, this lack of a toggle was a conscious decision, and was not made lightly.

I gave our reasoning in the bug, and I thought I’d include a copy here as well. Here goes:

Hey all,

So I’m going to talk a bit about the decision to move tabs in Thunderbird above the mail toolbar - and, more specifically, the decision to leave the UI toggle to move the tabs back to below the toolbar out.

When it comes to UI stuff, I can get pretty hand-wave-y and long-winded. In a departure from this, I’m going to try to be succinct here - please don’t interpret this as rudeness or brusqueness! :D

In Firefox, you have a back button, a forward button, and a URL bar to tell you where you are. With these rudimentary tools, the toolbar is easily generalizable to the act of navigation. This works for Firefox, because this is what Firefox *is* - a tool for navigating around the web. A high percentage of the things that you can do in Firefox involve navigation. Even in the Add-ons Manager, or Bookmarks Manager, the browser toolbar could make sense as a navigation interface (though we don’t seem to make those available - in fact, in the Add-ons Manager, we’ve created *new* back and forward buttons for navigation).

Where the browser toolbar *doesn’t* make sense, is in a place where navigation has less meaning. I’m going to pick on the Downloads Manager, for example. Firefox does not have the browser toolbar as part of the Downloads Manager, and outside of an add-on, such a customization is not really possible.

The reasoning behind this is obvious - having a back/forward/URL tools in the Downloads Manager makes very little sense.

So, the conclusion we can draw from this is: a shared toolbar makes sense in contexts that share the primary activity of that toolbar. This is why Firefox can get away with tabs-on-bottom for most of their UI.

Now, on to Thunderbird.

The rationale behind tabs-on-top in Thunderbird is somewhat different from Firefox’s. In Thunderbird, a tab can be many other things than just another Inbox tab.

Lightning, for example, gives us a tab that becomes a full-blown Calendering client. Unfortunately, they’ve had to deal with tabs-on-bottom, and have therefore been forced to shoehorn Calendering UI into the mail toolbar. If you’ve used Lightning, you know what I’m talking about.

This is not unique to Lightning. When viewing a content tab in Thunderbird, the mail toolbar above the content really makes very little sense - just like having the browser navigation bar in the Downloads Manager would make very little sense.

This is also quite restrictive. Thunderbird’s UI trajectory is tending towards more tab types (Search, Instant Messaging, eventually Compose in a tab, eventually Address Book in a tab). Having the toolbar exist *within* the tabs allows us a separation between these functions - and allows for a greater degree of customization *within* those tabs.

So I don’t think it’s fair to say that preventing tabs-on-bottom is making Thunderbird less configurable. On the contrary, I suggest that enforcing tabs-on-top is an investment that *ensures* greater flexibility and customization in the future.

All the best,

-Mike

Michelle Thorne: Feature Requests for Webmakers

thornet — Tue, 07 Feb 2012 14:01:29 +0000

As part of the on-going efforts to help webmakers the world over build & learn together, we’re collecting specs for event infrastructure. The Mozilla event menu is a piece of this, guiding community members to the event formats that best suit their needs and interests.

Once they’ve decided on an event type, organizers need a simple way to write up the event, spread the word, communicate with participants, and track outcomes.

Feature Requests

Thanks to conversations with Ben Simon, Jess Klein, Ross Bruniges, Matt Thompson, and others, we’re getting crisper on what features are essential to the Mozilla event infrastructure.

As an initial strawman, I proposed these features:

super simple event creation & categorization
localization-friendly
easy & secure data portability
good developer APIs
participant email capture and ability to mail them

I also think payment support is important, but not essential. At first, I argued strongly for it, because some organizers may need to recoup costs. But perhaps this is addressed by clearer sponsorship options and encouragement to use additional payment services, rather than a core requirement of our event infrastructure.

Another bonus feature is if the tools are already widely used and familiar to our communities. I think this is important for ease-of-use and discovery. For example, my friend Johannes uses Lanyrd to explore interesting upcoming events. Just yesterday he booked tickets to a festival he just discovered on Lanyrd that day. This suggests that if we don’t use popular listing sites, we miss out on potential participants. At the very least, strategic cross-posting should be encouraged.

Ben Simon has written an excellent post in response to the feature requests strawman. In it, he argues for these additional functions:

Ability for event organizers to organize over time: Communicate with participants before & after an event, plus allow sign-ups for single instances & repeated events
Groups: Search & find relevant events by geography, theme, skill level, etc.

Both of these are right on the money in terms of what we want our event infrastructure to support.

Prioritizing

Big questions we have now are:

Are the above features the most important?
Are we missing any?
And, once the list looks right, how to we deploy/build the infrastructure?

Over the coming weeks, I’m hoping to chat with people who’ve already organized events like the talented Heather Payne in Toronto (check out her upcoming Hive Toronto Pop-Up), Mozilla Kenyans Cliff Argwings & Alex Wafula and Product Dundee’s Jon Rogers & Mike Shorter, as well as people who’ve expressed interested in hosting something like Nick Doiron from CodeforAmerica, Christian Villum from Platform4, and Henrik Sandklef from FSCONS.

I’d like to get feedback on whether we’re prioritizing the right features and what would be helpful for them in future events.

There is also a big effort at the Mozilla Corporation to improve their event infrastructure, and we should definitely sync up & share solutions as much as possible.

3rd Party Audit

In parallel, we’re preparing for an audit of 3rd party event sites.

Considering there are companies that spend all of their time building event platforms, I argue that we should use those services, insofar they meet our needs, rather than coding something from scratch and maxing the bandwidth of our software team.

Ideally, the 3rd party site will feed into make.mozilla.org, a yet-to-be-coded aggregator for all the Mozilla webmaker activities.

On the list to investigate:

Lanyrd
Eventbrite
Meetup
350.org
Controlshift (still being built)
BlueStateDigital (which we currently use for some events and for Mozilla’s membership program)
also the Mozilla wiki, Where is Mozilla? and other in-house solutions

What other event sites do you really like? What do you use or see other people using well?

Images by Cyberdees from the Knight-Mozilla Hack Jam in Dundee.

Laura Hilliger: More System Thinking (at a Micro-Level)

laura — Tue, 07 Feb 2012 13:12:54 +0000

We’re still working on the Mozilla/P2PU Challenges for running an event. We’ve been through a number of iterations and are, at the moment, settling on a 1-2-3 format in which participants can access planning materials and sample content for any of the three types of events Mozilla champions. Michelle Thorne has created an Event Menu Lite that explains the event types, and we’re using the Hackasaurus Hacktivity Kit as a model for the “how to run a Learning Lab” portion of the Challenges.

Based on my system thinking chart, the event kit should include the three types of curriculum (ice breaker, instruction, design challenge), regardless of the type of event. The trick is defining each piece in a way that is broad enough that each event type can be included.

I’m thinking around this problem like this:

	Meetup	Learning Lab	Hackjam
Ice Breaker	Show and Tell. Discuss Concepts and Problems.	Show and Tell. Explain Concepts.	Show and Tell. Define Problems.
Instruction	Definition of the group’s goals.	Introduce Targeted Learning Objectives.	Crash Courses
Design Challenge	Make a plan to expand conceptual ideas from the Ice Breaker. Make a plan to reach goals defined in the Instruction.	Make using acquired knowledge from the Ice Breaker. Make using acquired skills from the Instruction.	Make by working to solve defined problems from the Ice Breaker. Make using acquired skills from the Instruction.

From a didactic standpoint, there are a couple of types of knowledge that are addressed in the three event types. A meetup could likely be categorized as “orientative knowledge” because participants are learning the connection between the chosen topic and their own lives (meetups are basically discussions). Learning Labs would likely be the next evolution with “instructional knowledge” because participants are receiving targeted lessons with specific learning objectives. A hackjam, then, serves to transfer “practical knowledge” as a participant will use pre-acquired knowledge to solve problems.

None of this is to say that one event type can’t or won’t transfer other types of knowledge, it’s simply a way to distinguish the learning goals of each event type. Understanding the overarching knowledge types will help us create curriculum that fits into each event type. This will allow us to be more efficient in our content creation, which means we will be able to create more content.

As always, comments are welcome and appreciated.

System Thinking (zythepsary.com)

Identity at Mozilla: ID provider support now live on BrowserID

Tue, 07 Feb 2012 13:04:00 +0000

Last week we pushed out a BrowserID feature that gets us closer to the decentralized identity system we envision for the Web. But more than that, it enables a truly awesome user experience—registration flows go from 8 screens to one simple sign-in. Seriously! See for yourself:

Chicken or egg

Some context: Building a distributed system is a chicken and egg problem - you have to design a system that can demonstrate the power of your idea and the advantages of a distributed architecture while you bring in participants who will become actual nodes in the system. That’s why, so far, BrowserID has operated with scaffolding that uses the BrowserID service itself to vouch for email addresses.

With our latest update, however, we’re setting aside some of that scaffolding and allowing a fully decentralized system to emerge: Identity providers can become full-fledged participants in BrowserID and directly vouch for their users’ email addresses.

What’s changed and what you need to know

If you’re a website that’s already implemented BrowserID, you don’t have to do a thing: BrowserID is just better for you! Up to this point, Browser ID has been vouching for users’ email addresses on behalf of participating websites. Now email providers can directly vouch for their users, eliminating the need for an email confirmation step or a BrowserID password.

Note that this change only takes effect when the email provider for a given address implements BrowserID support. Other email addresses continue to work in the same way they do today, with an email confirmation and password from the BrowserID service.

With ID provider support, users will have a better, faster, smoother registration experience.

Give it a spin.

Attention email providers large or small: whether you’re an enterprise, an ISP, a university or institution, you owe it to your users to check out this key new feature of BrowserID. Now it’s easy and incredibly simple for any email provider to become an identity provider for their users.

Try out our demo ID provider at eyedee.me and your @eyedee.me address on any BrowserID site. Take a look at our code and documentation. Let us know what you think via our mailing list, IRC channel, or via the Twitter hashtag #browserid.

Dan Sinker: The Knight-Mozilla Partnership Evolves

Tue, 07 Feb 2012 12:55:00 +0000

Change is awesome—it’s a necessary component to anything remaining vital and a required ingredient to facilitate organic growth. And so it’s with real excitement that today I’m announcing changes to the Knight-Mozilla News Technology Partnership.

Before we get to the changes, some quick background: Conversations around the original Partnership began in 2010, with the program launching at the start of 2011. That means that the program design, by necessity, reflected 2010’s problem-sets. Two years is an eternity on the internet—it was time to rethink and retool for today.

The community around code in journalism is vastly different today than in 2010: There are a number of app teams in some of the world’s best news organizations that embrace the “show your work” philosophy of open-source; organizations like Hacks/Hackers, NICAR, the Online News Association, and others are embracing the idea of hackfests and code-driven collaboration; and independent developers are starting to become interested in hacking journalism in earnest. These are awesome developments—this community is vital and growing.

The changes to the Knight-Mozilla Partnership for 2012 engage this larger community in meaningful ways:

We’re helping to sponsor and organize more than a dozen hackdays around the world this year. Hackdays are one of the best ways to get developers from all over to experiment with the idea of coding for journalism, and a great way to get some open-source code back into the community.
We’ll be increasing the opportunities for online learning that address the needs of the high-end developers we want to get interested in journalism, as well as a separate track for journalists who want to start becoming webmakers.
We’re also developing a stand-alone site, Source, dedicated to shining a spotlight on the vital work going on in the journalism code community through case studies, walkthroughs, tutorials, code snippets, and much more.
Of course, the biggest element of the Partnership, our Knight-Mozilla Fellowships, stays a vital center to the program. And in 2012 it grows—from five year-long fellowships to eight. There are some other changes in store for the Fellowships as well—that’ll be a topic for a blog post of its own soon.

These aren’t small changes—they alter what we’re doing in a lot of exciting ways. In fact, they’re big enough that we decided a new name and identity was in order. So the Knight-Mozilla News Technology Partnership, also known as MoJo, is no longer—welcome to Knight-Mozilla OpenNews. A new year starts right now.

Bogomil Shopov: Why the heck we need marketing guys at our perfect IT company?

Bogo — Tue, 07 Feb 2012 10:26:30 +0000

I am sure you know this modern company structure scheme:

пидорась == faggot
IT отдел == IT crowd/department/section

The past
I remember when I was younger and I was writing some bytes for living. I still know that there are just 10 types of people in the world: Those who understand binary, and those who don’t.

WTF?
I was wondering all my life why the heck we need a marketing and community management droids at our team. We create a kick-ass products that we can sell them via our web-page using 33 lines of HTML code an an Paypal account.

I am on the dark side of the force now and I know why.

The truth in 5 points*

If there is no marketing droids:

Less people know about us – our clients are our friends and peers and visitors from Google are welcomed too.
1 = Less money – well, I don’t have to explain this, do I?
2 = No salary++
3 = No beer money NOR I just got an invitation to work for another company that has a great marketing department.
R.I.P GPWGFTCCW (Great Product with great functionalities that can change the world.)

If there is no community management guys:

No community around us = We have to test our product by ourselves in any possible OS, CPU, RAM, ….
No community around us = How to know what to improve and what the clients really need from our products?
No community around us = How to get ideas for new products?
No community around us = How to find someone that will tell you honestly “You’re wrong”
No community around us = How to find someone who will help you with documentation, bug hunting, beer drinking, and to cheer you up – “You’re good. I love your product.”

* I am so sorry, but someone should change the ordered list to start from 0/zero/. Starting from 1 is so lame.

Jet Villegas: How to get started hacking the Firefox browser engine

jet — Tue, 07 Feb 2012 09:58:53 +0000

One of the Gecko Layout & Rendering team’s main responsibilities is the continuing development of CSS in Firefox. I recently modified the CSS style system to allow nested rule parsing. This bug fix taught me a lot about the CSS parser and how styles cascade through the rest of the Layout engine. It took me a little while to set up a dev environment, understand the bug, write tests, get the code written, reviewed, and checked in. I now have a much better understanding of what it takes to move code through the Mozilla source trunk.

I suspect that there are other programmers out there currently lurking around the Mozilla community, intimidated by the scale of the source tree, and wondering where to start hacking on Firefox. I highly recommend starting with the Gecko Overview started by L.David Baron, Mozilla Principal Software Engineer, to help beginners understand the browser engine. Thanks, David!

hacks.mozilla.org: Using the Battery API – Part of WebAPI

Robert Nyman — Tue, 07 Feb 2012 09:03:06 +0000

Detecting battery level in a device or computer can help you inform the user of the current status. Within Mozilla’s WebAPI, we have the Battery API to offer that possibility.

Accessing the battery

First, it’s a matter of accessing the battery object:

var battery = navigator.mozBattery;

Properties

There are a few properties offered to detect the charging level of the battery in the device:

Battery level: Check the currenty battery level. Returns a value between 0 and 1.
Battery charging: A boolean, returning if the device/computer is currently being charged.
Battery chargingTime: Time left in seconds until it is fully charged. Available when charging.
Battery dischargingTime: Time left in seconds until it is discharged. Available when not charging.

// Get battery level in percentage var batteryLevel = battery.level * 100 + "%";


    // Get whether device is charging or not

    var chargingStatus = battery.charging;
    // Time until the device is fully charged

    var batteryCharged = battery.chargingTime;

// Time until the device is discharged var batteryDischarged = battery.dischargingTime;

Events

There are four events available for detecting changes to the battery’s status:

levelchange: If the battery level changes.
chargingchange: Detect if the device went from being charged to unplugged, or vice versa.
chargingtimechange: When the device’s charging time changes (when plugged in)
dischargingtimechange: When the device’s discharging time changed (when unplugged)

battery.addEventLister("levelchange", function () {
    // Device's battery level changed
}, false);

battery.addEventListener("chargingchange", function () {
    // Device got plugged in to power, or unplugged
}, false);

battery.addEventListener("chargingtimechange", function () {
    // Device's charging time changed
}, false);

battery.addEventListener("dischargingtimechange", function () {
    // Device's discharging time changed
}, false);

Device support

Battery API is supported in Firefox Beta on:

Android (Firefox Aurora only, for now)
Windows
Linux (for those distros that have UPower installed – bundled with most nowadays)

Right now we don’t have anyone working on the Mac OS X implemementation, so if you have the skills, we’d love to see you contribute!

Demo and code

I’ve put together a basic demo of the Battery API and code is also available in the Battery API repository on GitHub.

If you don’t experience the expected results on your device, please file a bug and we can look into it. This feature is experimental at this time, and may not be ready for production use just yet.

Bonjour Mozilla: Tim Taubert et Felipe Gomes

clarista — Tue, 07 Feb 2012 09:00:00 +0000

(Photo : autonome)

La semaine dernière, en préambule du Fosdem, l’équipe performance et une partie de l’équipe frontend de Firefox étaient en goguette à Bruxelles. Enfin… en goguette… Nos vaillants développeurs se sont astreints à une difficile semaine de travail (une vidéo ici), entrecoupée de moments de détente. Comme ici, Tim Taubert et Felipe Gomes. Tous deux travaillent sur l’interface utilisateur de Firefox.

Depuis Berlin, où il réside, Tim a pour habitude de coder en musique. Il conjugue ainsi ses 2 passions : le son, et le code. Tim est libriste affirmé, contributeur à Gentoo, ainsi qu’au noyau Linux… avant de rejoindre le Panda Roux qu’il décrit comme un “compagnon loyal”. Bonjour Mozilla vous conseille de lire son billet sur la façon dont il est devenu un contributeur Firefox, très instructif.

De son côté, Felipe Gomes est un jeune développeur, tout juste diplômé, qui n’a qu’une ambition: “aider Mozilla à rendre le Web meilleur”. Jeune diplômé, donc, mais contributeur de longue date, et nouvel embauché. Felipe a fait le code initial pour gérer le multi-touches dans Mobile, alors qu’il était stagiaire. Aujourd’hui, le voici donc dans l’équipe frontend, où sa bonne humeur est très appréciée !

Bonjour Tim, et bonjour Felipe !

PS : et merci à Mike Hommey (Glandium) pour son aide !

Last week, as a preamble to Fosdem, the Firefox performance team and a part of the frontend team were gallivanting in Brussels. Well, not exactly… Our brave developers compelled themselves to a hard work week (a video here), interrupted by some recreation times. Like here Tim Taubert and Felipe Gomes. Both are working on Firefox user interface.

From Berlin, where he lives, Tim is used to listening music while he writes code. He combines his two passions as well: sound and code. Tim is a Free Software advocate. He contributed to Gentoo, and to the Linux kernel… before joining the Red Panda which he describes as a “loyal companion”. Bonjour Mozilla advises you to read his post about how he became a Firefox contributor: very informative.

Felipe Gomes, on the other hand, is a young, recent graduate developer, whos one and one ambition is to “help Mozilla make the Web better.” Recent graduate, then, but long-time contributor and new employee. Felipe created the initial code to handle multi-touch in Mobile when he was an intern. Today, he is part of the frontend team, where his good humor is much appreciated!

Bonjour Tim, and good morning Felipe!

PS: thank you to Mike Hommey (Glandium) for helping!

Paul Rouget: Bugzilla Activity Report

Paul Rouget — Tue, 07 Feb 2012 08:00:00 +0000

Bugzilla has an interesting feature: User Activity Report.

I didn't know about it until someone mentioned it on IRC yesterday. It's quite useful if you keep track of your daily/weekly work.

Also, if you want a prettier output, here is a script that will help. Run it in Scratchpad (Shift-F4):

Gian-Carlo Pascutto: New SafeBrowsing backend

noreply@blogger.com (Gian-Carlo Pascutto) — Tue, 07 Feb 2012 07:45:35 +0000

Today, the SafeBrowsing rewrite me and Dave Camp have been working on for several months finally landed in the Mozilla Nightlies, and it should be part of the Firefox 13 release, narrowly having missed Firefox 12. It reduces the disk footprint of our anti-phishing and malware protection from about 40-50Mb to 5-6Mb, changes all related I/O from pure random access to a single serial read, and refactors a single 4000+ line C++ file into a bunch of modules. An earlier part of this work landed in Firefox 9 and reduced the memory footprint from potentially up to 40-100M to 1.2M, as well as removing the need to do some random I/O on every page load.
Aside from the performance gains, the reduced footprint is an essential step to enable us to extend our SafeBrowsing protection to Mobile devices, which is why we undertook this in the first place.

It was an interesting assignment, and being my first real project for Mozilla, a bit more involved than we thought at first. I blogged in July last year about our plans for this feature. Some of the optimizations we had in mind didn't work out, while others did end up being implemented.

Eliminating the host keys

One of the things touched upon in the previous blog post was that we used to store 2 32-bit hash prefixes for every blocked entry: one encoding only the host and the other encoding the full URL. Strictly speaking, we only need the full URL part. The old SQLite based code used the host key to SELECT and load all keys for a certain domain at once, but our new in-memory prefix-trie based approach has no such needs. However, as Justin Lebar alread touched upon in the previous blog, this does significantly increase the likelihood that we get a false positive. We now expect to have a false positive for every 7000 URLs visited. This will not cause us to block out any legitimate sites, as any positive hit in the local database is queried against the full, 256-bit hash at a remote server (hosted by Google, who provides the SafeBrowsing data).

This does mean we will increase the traffic to this remote server by a large factor. Scary as it may sound, some back-of-the-envelope estimates shows its not really that bad: say there are about 420M Firefox users, browsing for 8h/day. They load on average 1 URL per second. This means about 140M URL loads per second, causing about 20000 hash requests per second to Google. Google confirmed they can handle this with ease.

Now, there is still a problem when doing this: any collision will appear for all users on exactly the same URLs. This means that if you're unlucky enough to be a a site owner that has an URL that happens to collide, every visitor to your site will have a slightly slower browsing experience. Even worse, should you get linked in a popular forum, or be in the news, there will be a storm of false positives to the server all at once. We thought this to be problematic enough that we implemented a workaround: every user will generate a unique randomization key and re-randomize all his hashes with it. Collisions will happen on a different URL for every user, and consequently also be much better spread through time.

Eliminating chunk numbers

After some discussion, it turned out eliminating the chunk numbers isn't as easy as hoped. First of all, the observation in the previous blog posts that chunk expires only seem to happen when the chunks are in fact old, doesn't hold after observing the protocol for a longer time. It also happens very regularly that a chunk is added, deleted, and added back again, particularly in the malware list. In those cases, it is important to know which add chunk a delete is referring to, so it won't delete the later add. It would still be possible to deal with that if the server recalculates the prefixes to send for every client, but this is less efficient on the server side compared to the bigger, more static downloads that the server can point to now, and which are easily mirrored on Google's network.

Sub prefixes compress harder

In line with the previous paragraph, it happens that we receive sub prefixes for add prefixes we never received. These must be kept around until we receive an expire for them, as we can't know if the add they belong to is outdated or just not downloaded yet. Note also that we usually receive updates backwards, i.e. the most recent data will be sent to the clients first, as it's the one believed to be most relevant. Because sub prefixes contain both an add and a sub chunk, they are also bigger than add prefixes. This causes the eventual size of the database to be a bit more than the minimum guessed in the previous blog post, which more or less ignored sub prefixes entirely. If you peek in your profile, you can see that the goog-malware-shavar.sbstore will tend to be the biggest file: this is exactly due the many sub prefixes in the malware list.

Detection performance

It should be noted that these improvements are purely focused on the footprint of the feature. They will improve the resource usage of the browser, but they do not change the detection performance in any way.

NSS Labs Report

In what is somewhat of a funny coincidence, the same day I am writing this blog NSS Labs published a report "Did Google pull a fast one on Firefox and Safari users?". The main points of this report shouldn't be much news as I pointed out over half a year ago the discrepancy between Chrome, and Firefox and Safari in my previous blog post, as well the reason ("Performance differences between Firefox, Chrome and Safari").

I have two remarks to the report: one, as I've already pointed out in the past, false positive control is an important part of effective malware detection. Internet Explorer flags many malware sites, but it also flags legitimate sites, undermining the true effectiveness.

Secondly, the problem isn't so much that the "new" SafeBrowsing protocol is proprietary or non-documented; it's implemented in Chrome and Chromium is open source, so at the very worst we can go study that code to see how to implement it. The problem is that permission is required to use Google's SafeBrowsing servers, and ~~Firefox does NOT have permission to use the download protection list~~. Edit: Please see the statement from Ian Fette below.

Smokey Ardisson: Dear Apple

Smokey — Tue, 07 Feb 2012 07:34:06 +0000

Someday—in my lifetime—will you please make the current, native, recommended .sdef scripting definition format less buggy than the old, less powerful, and implicitly not recommended .scriptSuite / .scriptTerminology format?

Thank you. That is all.

Gen Kanai: Mozilla Myanmar at Barcamp Mandalay

Gen Kanai — Tue, 07 Feb 2012 06:11:29 +0000

Chit and Thanyawzinmin (Tin Aung Lin) from the Mozilla community in Myanmar recently represented Mozilla at BarCamp Mandalay. Please go over to Chit’s blog to read all about it!

https://ahkeno.wordpress.com/2012/02/06/mozilla-myanmar-at-barcamp-mandalay/

Jess Klein: Storytelling- Day One of Design Sprint "Webmaking for Journalists"

noreply@blogger.com (Jess) — Tue, 07 Feb 2012 04:12:51 +0000

Today was the first day of the Open News - Webmaking 101 design sprint. Thanks to Hive NYC member Peoples Production House for graciously volunteering to host us! The team for our sprint includes:

pictured: erin knight, chris lawrence, michelle levesque, dan sinker, atul varma, brian brennan, jess klein and mark surman (not included are some top secret special guests who shall be named later this week!)

We started the day airing out our joint concerns about the direction of the project. It turns out, I wasn't the only one who was concerned about the tool not making sense within the range of potential tools that we might be developing at Mozilla. We all discussed what a journalist would want to make- and agreed that a journalist would want to use the web to tell their story. While this might sound simplistic, this is a topic that I am much more comfortable developing a project around compared to something like Webmaking 101 for Journalists. As I talked about in my last post, here is an example of a potential user who has a deep interest and motivation to make something (a story) using the web- and thus there is the opportunity to embed learning into this moment. Also, I think that the idea of storytelling has the potential to reach different kinds of learners (although it could certainly appeal to journalists)- including filmmakers, poets, youth etc.

We came up with a few goals for the week, including:

create a dirty working prototype- it doesn't have to be pretty, just having some functionality
designing some badges for the prototype

After determining our goals, we set to work reviewing the learning objectives for the project. This is a key thing for us to to review, because we wanted to make sure that the project fell within the scope of web literacies that are being defined for Mozilla. We had a good conversation about what could be included and what was out of scope for the project. Here is a little venn diagram that shows the domains within Mozilla's web literacies that this particular project will be addressing.

Essentially, there are 6 clusters/modules/ steps that we will be exploring through this exercise in helping people to tell their story through the web (below). While we will offer the skills in a series, ideally the user will have the opportunity to take these modules out of any particular sequence.

All about Tags
Style Your Stuff
Images
Links and the Open Web
Embedding and Beyond
Sharing

In our first brainstorm, we discussed using these 6 modules as guides for badge distribution within the context of the prototype.

Tomorrow we will be mapping these modules and learning objectives to storyboards for the instructional overlays and starting to work on developing out the content and copy for that section. I am really excited with the direction that this project is going and with our re-envisioning of the learning objectives as well as scope.

Meeting Notes from the Mozilla community: Mozilla Project Meeting Minutes: 2012-02-06

Jesper Kristensen — Tue, 07 Feb 2012 04:00:04 +0000

WeeklyUpdates/2012-02-06

< WeeklyUpdates

« previous week | index | next week »

Dial-in: conference# 8600
- US/International: +1 650 903 0800 x92 Conf# 8600
- US toll free: +1 800 707 2533 (pin 369) Conf# 8600
- Canada: +1 416 848 3114 x92 Conf# 8600

Friends of the Tree

Aleksej, gaby2300, lcamacho, Swarnava for triaging the most Firefox 11 bugs during QA’s Firefox 11.0b1 testday last Friday
Ed Morley for all around awesomeness.

Upcoming Events

This Week

Monday, 06 February

Tuesday, 07 February

Wednesday, 08 February

Thursday, 09 February

Friday, 10 February

Next Week

Product Status Updates

Firefox Desktop

Speaker Location: Toronto (johnath)

Firefox 10 went out last week, with addons compatible by default
Dig Lawrence’s blog post about silent updates, most of which has already landed
Then check out Jared’s performance work week recap
And then try out the Firefox/Features/New_Tab_Page new tab page (bug 455553) on nightly.
Oh, and gcp just replaced the safebrowsing database with a flat file (bug 673470), resulting in better IO performance and reducing the DB from 60MB to 6MB.
I thought I told you that we won’t stop.

Firefox Android

Speaker Location: Toronto (johnath)

Beta build with Native UI should happen this week
- It’ll be en-US only while we figure out the best way to package/distribute multiple locales

Thunderbird

Speaker Location: Toronto (bwinton)

Thunderbird team is having a meet-up in the Toronto office this week.
- Come and say Hi if you’re in the area.
Thunderbird 10 and Thunderbird 10 ESR released last week
3.1.x end of life announced for 24th April.

Older Branch Work

Speaker Location:

Drumbeat

No voice update this week
Check out Chris Heilmann’s awesome post & presentation on Mozilla Popcorn and the future of web-enabled video. From London’s news:rewired.

Identity

Speaker Location:

Speakers

The limit is 3 minutes per speaker. It’s like a lightning talk, but don’t feel that you have to have slides in order to make a presentation.

Title	Presenter	Topic	Media	More Details
SCL3	IT/Infra & Ops (no intro needed, video speaks for itself)	Mozilla’s Santa Clara data center	The Video	Project: SCL3 blog

Status Updates By Team

Firefox

Platform

Messaging

Mobile

IT

Release Engineering

QA

Test Execution

WebQA

Affiliates
- Successful push, bug 722478
- Rajeev [:rshetty] led the release. Transitioning in as the QA lead on the project.
AMO
- AMO 6.4.0 is going live on 02/03
- Paypal Contribution test is merged
- MPL2 license is merged
Engagement
- Careers is blocked on one bug, waiting for ckoehler
- DTPT Phase II is complete
Mozilla.com
- shipped bugs for Firefox 10.0 release on 01/31
MDN
- shipped milestone 2.1
Socorro
- Successful 2.4.1 milestone released – bug 723185
SUMO
- 1/31 release went out, 25% of users are currently on Elastic search
- 2/7 release in process
Case Conductor
- Working towards feature parity with new django build, aiming for early February

QA Community

Automation Services

Blog post: Mozmill Crowd 0.1.5 released
Blog post: Case Conductor: I guess we could document it…
Blog post: Automating BrowserID with Selenium
Blog post: FOSDEM 2012, Add-on SDK, and slides for Mozmill CI

Automation & Tools

Worked with QA team to bring up automated testing of top 100 addons for default to compatible. Results are here. Still looking through failures, nothing unexpected at this time.
Much closer to working fennec arm v6 build
Marionette-gaia tests (b2g) are now running green
First pass of Talos + Jetpack (jetperf) is moving into its beta stage.
More news here

Security

security team Work Week in Santa Cruz, no reviews this week.

Engagement

PR

As Firefox 11 Hits Beta, Work Begins on Push Notifications for the Web

Events

A call for participation from paid staff will be sent out on February 10th. Volunteer invitations will also be sent out on this day. Please email knaszradi@mozilla.com if you have any questions.

Creative Team

Community Marketing

Support

Metrics

Evangelism

Labs

Apps

Demo Apps lining up for MWC
Apps Showcase launched Friday at noon in MV see Apps/ShowAndTells

Developer Tools

Add-ons

Webdev

L10n

People Team

WebFWD

We just launched our Affiliates Program > become one (we’re listed under “Mozilla” at http://blog.webfwd.org/post/17155951369/become-a-webfwd-affiliate)!

Introducing New Hires

New Hire	Introduced by	Speaker location	Will be working on
Who is the new hire?	Who will be introducing that person?	From which office will that introduction be transmitted?	What will the new person be working on?
Joel Aguilera	Jill Van De Ven	Mt. View	Payroll Administrator
Bonnie Surender	Johnny Stenback	Mt. View	WebAPI team
Cody Brocious	Faramarz Rashed	New York	System Engineer B2G
Wesley Kocher	David Mason	Dakota City, IA	Bug Master/Release Engineer
Trevor Norris	Gilbert FitzGerald	Mt. View	Metrics Engineer

Introducing New Interns

New Intern	Introduced by	Speaker location	Will be working on
Who is the new intern?	Who will be introducing that person?	From which office will that introduction be transmitted?	What will the new person be working on?

Foundation Updates

Roundtable

Retrieved from “https://wiki.mozilla.org/WeeklyUpdates/2012-02-06“

Firefox Support Blog: What’s Up With SUMO – Feb. 6

Verdi — Tue, 07 Feb 2012 03:09:02 +0000

Download video: MP4 format | WebM format

Big things this week

Next SUMO meeting – Monday, Feb. 13th (call in details & meeting notes) at 9am PST. Please add your comments, questions and updates to the wiki. You can also participate in #sumo during the meeting. We’re going to record and post a video of the meeting.
Next SUMO release – Tuesday, Feb. 7th
Video of the SUMO meeting (embeded below).
Our new search engine is serving 50% of our searches.
UX work is ongoing. We’ll be testing a new information architecture with users soon.
Home page experiment is working well. We got rid of lots of questions that were already answered by an article.
Cheng is working with Engineering and UX to do something about search hijacking.
Notes from this SUMO meeting.

Mozilla Add-ons Blog: Add-on SDK 1.4.3 Released

Dave Mason — Mon, 06 Feb 2012 23:03:50 +0000

We have identified a serious bug in the 1.4.* releases, and have made a hotfix release of the Add-on SDK. The hotfix release is version 1.4.3.

If you are potentially affected by the bug, then you will need to take action to recover from it.

This note explains:

how to work out whether you are potentially affected
what the impact is
how to recover from the bug
what went wrong

Are You Affected?

You are potentially affected by this bug if you meet ALL THREE OF the following conditions:

Your add-on uses any of the following SDK modules: simple-storage, passwords, simple-prefs. Using passwords is only a problem if you’re using it to store passwords specific to your add-on, rather than just web site passwords).
You did not explicitly specify an ID for your add-onThis means: you didn’t edit your “package.json” file to set your add-on’s ID, so the first time you ran `cfx`, it generated an ID for you in “package.json”.If you’re not sure about this, open your add-on’s “package.json” file and examine its “id” entry. If it does not contain “@”, and is not in the form: “{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx}”, then it is an auto-generated ID and you meet this condition. For example:
```
    "id": "jid1-MKxcan0H26wiRw"
```
You have ever built and distributed your add-on using the 1.4, 1.4.1 or 1.4.2 releases of the SDK This means either:
- you initially built your add-on with 1.4, 1.4.1 or 1.4.2
- you initially built your add-on using 1.3 or an earlier release, but rebuilt it using 1.4, 1.4.1, or 1.4.2.

What’s the Impact?

The impact of this is:

1. suppose your add-on was originally built and distributed using a version of the SDK earlier than 1.4. People use it, and store data with it, using the simple-storage or passwords modules. Then you rebuild using SDK 1.4/1.4.1/1.4.2. Now, any data which users had previously stored in simple-storage, and any add-on-specific passwords stored using passwords, will seem to have disappeared. You must upgrade to 1.4.3 to recover this data.

2. suppose your add-on is built using SDK 1.4/1.4.1/1.4.2. People use it, and store data with it, using simple-storage, simple-prefs, or passwords. Then you upgrade to version 1.4.3. Now, this data will apparently disappear. You must take steps to recover this data.

How To Recover

First, upgrade your add-on to use 1.4.3. After this, data entered using releases of the SDK before 1.4 will reappear.

Next, you’ll have to recover any data that users entered using the 1.4/1.4.1/1.4.2 versions.

To help with this we’ve written a module called “recovery.js”. This module won’t ship with the SDK itself, though.

If you’re using the Add-on SDK, download “recovery.js” from https://gist.github.com/1733262 and save it in your add-on’s “lib” directory.
If you’re using the Add-on Builder, move your mouse over “Libraries” in the left-hand sidebar until a plus sign appears next to it, then click the plus sign. Then in the dialog type “recovery” and select “recovery by gozala” to add it to your project:

You need to import the recovery module in the normal way:

var recovery = require('recovery');

The recovery module contains any data that was written using simple-storage, simple-prefs, and passwords while your add-on was built with the 1.4, 1.4.1, or 1.4.2 releases of the SDK. The data is stored as three properties, one for each module:

recovery.storage
recovery.prefs
recovery.passwords

You’ll need to merge these properties with the data stored in simple-storage, simple-prefs, and passwords in whichever way makes sense for your add-on.

The files at https://gist.github.com/1733262 include some examples of performing this merge using the recovery module.

What Went Wrong

SDK-based add-ons have an ID, which is used for, among other things, figuring out which stored data belongs to this add-on. The ID is stored in the add-on’s “package.json” file. If you do not specify an ID for your add-on by editing “package.json” directly, then the SDK generates one for you automatically.

This auto-generated ID in “package.json” looks something like “jid1-y1AFbAhD9jXVcg”. The SDK takes this value and appends “@jetpack” to it, and uses the result as an ID. So if you call:

console.log(require("self").id);

…you’ll see something like:

 info: jid1-y1AFbAhD9jXVcg@jetpack

This value is then used as a key for data stored using simple-storage, simple-prefs, and certain data in passwords (specifically, passwords that are associated with your add-on rather than a web site).

In 1.4 we broke the code that appends “@jetpack” to the ID. This means that a 1.4/1.4.1/1.4.2 add-on will look for data using just “jid1-y1AFbAhD9jXVcg”, and won’t find any data that was entered using an add-on built against an earlier version of the SDK.

In 1.4.3 we are reverting that change: so a 1.4.3 add-on will look for data using “jid1 y1AFbAhD9jXVcg@jetpack”. This means that a 1.4.3-based add-on it will find data which was entered using an add-on built using pre-1.4 release of the SDK. However, a 1.4.3 based add-on *will not* find data entered using an add-on built against 1.4/1.4.1/1.4.2. That’s why you have to recover that data explicitly.

We considered making the 1.4.3 release perform automatic recovery, looking for data stored under “my-jid”, and if it finds any, automatically updating the version stored under “my-jid@jetpack”. But the structure of stored data is very specific to an add-on, and we decided that there was a significant risk that automatic update would break some add-ons, so it’s safer if each add-in implements its own recovery.

Getting In Touch

As always we’d love to hear from you about your experiences. And we are always available to help with issues you may encounter. You can contact us in a variety of ways:

post to our discussion group
chat with us on irc.mozilla.org #jetpack
report a bug
check out the source and contribute bug fixes, enhancements, or documentation

Ben Simon: The infrastructure for self-organizing

Ben Simon — Mon, 06 Feb 2012 22:35:20 +0000

One of the more exciting tasks that I’m working on at Mozilla is figuring out the challenge of getting people around the world to participate in the project of going from using the web to making the web — building a generation of webmakers — but doing it together, at events. Briefly, the idea is to try and apply something akin to the offline, engagement organizing models normally used in successful grassroots political campaigns to our learning/webmaking initiatives.

Mozilla Japan Scratch/Hackasaurus Pop up. Photo from Mark Surman

Michelle Thorne has already done a bunch of thinking about how this maps across our events — her event menu is here — and I’m trying to think about what type of infrastructure we’ll need to set up to get people to organize these types of things on their own (with our support, or course).

There are some pretty clear functionalities that are needed, which Michelle has laid out elsewhere, beyond simple event creation & categorization — localization, data portability & access, good developer APIs, participant email capture, and more.

In addition to those, there are a couple that seem necessary to me to be reasonably effective:

–Ability for event organizers to organize over time: This means an ability to create an event (on one or many days or several events in a series) and have the ability to directly communicate, over time (so both before and after the event) with the people who sign up to take part.

Most tools — even those with something like this — seem to lack either the ability to communicate with attendees at all, or, even if they have that, lack the ability to do so over time and across events. Example: I want to start a weekly meetup. Within the Mozilla event infrastructure, I should be able to create an event once and set it to happen every week at Time X. I should be able to change the event time of a given week. People should be able to sign up for one/all/some of those events. And I should be able to communicate with all the attendees (who have opted in to communications, of course) both before and after the events.

–Groups: Part of this whole thing needs to be people easily finding and joining groups of people they’d want to talk to — that could be based on geography, ability, program, interest, whatever. These should be easy to search for, find, and join, and allow people to discuss things and move forward in their own way. This could be anything from glorified listservs to something more Facebook-y, but it’s definitely important for fostering an engaged core of people doing this stuff.

Now, there are examples of organizations doing things like this — or at least setting up infrastructure close to it — quite successfully. From Rebuild the Dream to Code Year to Tedx and a whole lot more, they’re out there, but generally there’s something making each not quite what we need, or not quite what would work in this context.

So the questions are as follows:

1) Is the description of needed functionality above correct? Are there gaping holes, or things that aren’t necessary?
2) How should we create that infrastructure?

There are platforms out there which meet some, but not all, needs. There’s Meetup Everywhere, but what’s really needed is a combo of Meetup Everywhere with the richer functionality you can have as an individual user of Meetup. 350.org is building its own tool in the open, which could potentially be forked for our needs — https://github.com/350org/localpower. There are tools that don’t yet exist (ex: http://www.controlshiftlabs.com/) and then there’s the better known tools from BSD to Action Kit to EventBrite to Lanyrd and more. BSD is what we use for other things, but their event tool unfortunately wouldn’t localize too well. Otherwise it would have almost everything else.

So, what say you, techies, organizers, people who care? Please chime in with thoughts on any of this — or thoughts on anyone else I should try and talk with — in comments. Thanks!

Also, many thanks to, among others, Jim Pugh & Nathan Woodhull for recent discussions that have helped crystallize my thinking enough to get to where I currently find it.

Robert Accettura: How To Fix Broken about:home Search In Firefox

Robert — Mon, 06 Feb 2012 22:11:14 +0000

Not that I recommend it, well actually I have, and do for “advanced” users (I will update that at some point), but occasionally cleaning out your Firefox profile can be a good thing. Every so often I clean the cruft out of mine. Here’s a little quirk however. The new-ish browser start page won’t perform a search when localStorage is cleaned out. It will manifest by simply doing nothing when you try to search. The form goes nowhere. If you look for errors in the console you’ll see:

"gSearchEngine is null"

The best solution I’ve found to fixing this is to go into about:config and reset (right click -> reset) these properties and restart:

browser.startup.homepage_override.buildID
browser.startup.homepage_override.mstone

I suspect it’s just buildID, however neither should be harmful. Restart and they will be recreated.

Matt Thompson: Mozilla DML Science Fair: prepping for blast off

openmatt — Mon, 06 Feb 2012 22:01:09 +0000

Mozilla is hosting a giant “Science Fair” at the March 1 “Digital Media and Learning” conference in San Francisco. Our mission: gather folks doing amazing work at the intersection of learning, youth and the web, have them set up 20+ booths and interactive show-and-tell stations, then invite educators, youth and local SF VIPs to all mingle, chat and get their hands dirty.

You can learn more or have a look at how the DML Science Fair is coming together here.

Cool re-usable “open branding” elements for all our events

As Mark wrote last week, we were blown away by the terrific job the Mozilla Japan team did in creating a fun physical presence for the Vision 2012 event. So we want to try and replicate their work for the Science Fair.

Mozilla Japan’s Tetsuya Kosaka was kind enough to send us their original assets, and we’ve simply tweaked the language on them for the event (below). We’re hoping to re-use and re-purpose them at other upcoming events.

I like the way these signs contain clear Mozilla branding, but also open whiteboard space for exhibitors and friends to decorate and put their own stamp on it. Feels very Mozilla — like “open branding.” Plus a lot more versatile and re-usable.

We may eventually update the visual language beyond the “space” theme, but for now it seems great and very “Science Fair-ish.”

Science Fair exhibitor whiteboard

...in six different versions

Plus cool little stand-up elements like these

...in the same six versions

Generic Mozilla whiteboard sign

11 x 17" wayfinder signs

Name badge stickers for presenters

Tim Taubert: Status Update [:ttaubert] – 2012-02-06

Tim Taubert — Mon, 06 Feb 2012 20:08:35 +0000

New patches:
* bug 720838 – [Page Thumbnails] Use canvas.mozFetchAsStream()
* bug 720697 – Provide internal API to get canvas image data as nsIInputStream
* bug 669603 – large sessionStorage data causes session restore to block the UI
* bug 666538 – Use Telemetry to collect Panorama usage/perf data
* bug 721019 – [Page Thumbnails] Add telemetry probes
* bug 722479 – browser/components/thumbnails/test/ tests leak chrome://global/content/mozilla.xhtml
* bug 716532 – [New Tab Page] Remove “site strip” at the top and re-style buttons
* bug 722663 – open a new tab from Panorama view should reference gWindow.BROWSER_NEW_TAB_URL
* bug 723852 – Use a runnable for canvas.mozFetchAsStream()
* bug 723102 – [New Tab Page] Can’t Hide/Show New Tab Page when closing left tab
* bug 721417 – Can’t drag and drop URL into about:newtab
* bug 695705 – Intermittent TEST-UNEXPECTED-FAIL | browser/base/content/test/tabview/browser_tabview_bug628061.js

Filed bugs:
* bug 722650 – [New Tab Page] Long hang when first enabled in a profile
* bug 723852 – Use a runnable for canvas.mozFetchAsStream()
* bug 724225 – Lots of reflows and flickering when using IRCCloud

Feedback and review:
* bug 722100 – Use ondblclick instead of hard-coded time interval to detect double clicks on ui.js
* bug 722460 – gBrowserThumbnails uninit sets a property that has only a getter
* bug 388079 – Deleting multiple cookies deletes wrong ones and/or not all selected
* bug 722663 – open a new tab from Panorama view should reference gWindow.BROWSER_NEW_TAB_URL
* bug 723515 – Add telemetry probe for the opening time of the Firefox app menu

Landed
* bug 721087 – [New Tab Page] Cells should have an outline to indicate their positions
* bug 716538 – [New Tab Page] Set to enabled by default on Nightly
* bug 720697 – Provide internal API to get canvas image data as nsIInputStream
* bug 707862 – Reset childCount on SHEntry when all children have been removed
* bug 721019 – [Page Thumbnails] Add telemetry probes
* bug 722479 – browser/components/thumbnails/test/ tests leak chrome://global/content/mozilla.xhtml
* bug 722663 – open a new tab from Panorama view should reference gWindow.BROWSER_NEW_TAB_URL
* bug 723852 – Use a runnable for canvas.mozFetchAsStream()
* bug 723102 – [New Tab Page] Can’t Hide/Show New Tab Page when closing left tab

* Merge Fx-Team and UX branches

Next:
* bug 720838 – [Page Thumbnails] Use canvas.mozFetchAsStream()
* bug 669603 – large sessionStorage data causes session restore to block the UI
* bug 721019 – [New Tab Page] Add telemetry probes
* bug 716532 – [New Tab Page] Remove “site strip” at the top and re-style buttons
* bug 721417 – Can’t drag and drop URL into about:newtab
* and other various New Tab Page bugs

Coordination:
* Returned from Performance work week and FOSDEM

Lawrence Mandel: Firefox Engineering Program Management 4Q 2011 Summary

Lawrence Mandel — Mon, 06 Feb 2012 19:51:20 +0000

The Firefox engineering program management team formed at the end of 3Q 2011. The team is currently comprised of Sheila Mooney (smooney – our fearless leader), Martin Best (mbest), Erin Lancaster (elancaster), and me (Lawrence Mandel – lmandel). Our first whole quarter as a team was 4Q 2011. Looking back over the last three months, I find it quite amazing how far the reach of the team has expanded in this time. Here’s a short summary of the efforts in which the team was involved in 4Q 2011. You can also track our team against our 4Q goals.

Mobile

Back in October it was decided to rewrite the Firefox mobile UI as a native Android application. This is no small feat. Erin stepped up as the project manager for this effort and has been doing an amazing job. If you haven’t seen the progress that this team has made in 3 months check out the latest Nightly or Aurora builds. I can’t wait to see this effort reach the first release of the new native Android application early in 2012.

Silent Update

Transforming the Firefox update experience into a silent update experience is another big task that requires changes to the way the browser handles update related prompting including restart, Windows user account control (UAC), and information pages, the update operation itself, and add-on compatibility. Lawrence has been managing this effort, which landed changes for the restart prompt, the what’s new page, and add-ons default to compatible in Q4. The remaining changes are slated to land in 1Q 2012 with all features being released in the 1H 2012.

Bugzilla Anthropology

In an effort to better understand our project’s use of bugzilla, Martin conducted a series of interviews with Mozilla contributors on various teams. The goal of this project is to understand how people use bugzilla. Martin put together a good blog post that provides details about this important project.

Crashkill

Sheila continued to run the ever important Crashkill program that monitors and acts on Firefox stability issues. Along with supporting Firefox desktop, the Crashkill program has been actively contributing crash reports to the new mobile native UI rewrite.

Telemetry

Lawrence picked up management of Telemetry with the immediate goals of improving the Telemetry adoption rate, improving the consumability of the Telemetry dashboard, and increasing adoption of the framework by the implementation of more probes. 4Q saw the release of v2 of the Telemetry dashboard and the initial efforts to improve adoption of this data collection framework among the users on the various Firefox channels. 1Q 2012 will see an improved Telemetry adoption rate, continued work on the dashboard, and even more probes.

Snappy

In October Firefox project leadership made a decision to put the electrolysis effort on hold to focus resources on short term responsiveness gains. The result of this is project Snappy, which kicked off late in 4Q. Lawrence is managing Snappy, which includes broad membership from various front-end and platform teams. In 1Q we plan to move from investigation to solutions. Look for changes to start landing as early as 1Q.

HTML5 Games

Martin kicked off a new effort late in the 4Q to make Firefox an awesome platform for HTML5 based game development. There is lots more coming in 1Q on this active effort. You can follow along on the HTML5 games wiki page.

Tagged: firefox, mozilla, program management

Marco Zehe: If you use the WAI-ARIA role “application”, please do so wisely!

Marco — Mon, 06 Feb 2012 19:35:52 +0000

This goes out to all web developers out there reading this blog and implementing widgets and other rich content in HTML, CSS and JavaScript! If you think of using the WAI-ARIA role “application” in your code, please do so with caution and care! And here’s why:

What is it?

“application” is one of the WAI-ARIA landmark roles. If you’d like to read up on landmarks, please go here. It is used to denote a region of a web application that is to be treated like a desktop application, not like a regular web page. In other words, if you use something that is not part of standard HTML, like a mashup widget, and your page has no resemblance to a classic document in, roughly, over 90% of its content, “application” is for you. If you, on the other hand, make up a user interface solely of elements that are part of standard HTML like selects, check boxes, text boxes etc., and in addition use only common compound widgets and lots of document-like content like hyperlinks, you will most probably not want to use “application” because browsers and assistive technologies provide a standard interaction model for these already and don’t need special support from you in that.

Why use it at all?

Traditionally, assistive technologies like screen readers for the blind convert a page’s content into a format that is easier for a person with a disability to comprehend. A two-column newspaper style text, for example, is reformatted so that the text flows from beginning to end like it would in a single-column document. Multi-column layouts of pages are streamlined so that there’s a structured flow a person who, for example, cannot see the screen, can understand.

For this, screen readers especially on Windows have adopted a two-part user interaction model:

virtual cursor or browse mode: This is the mode screen readers especially on Windows operate in when the user browses a web page. The term virtual cursor has been used since its inception in 1999 because this feels to the user like a document in, for example, WordPad or MS Word. The user walks the document using the arrow keys and has the text to them read via the speech synthesizer. In addition, semantic information is spoken to indicate whether a particular piece of text is a link, graphic, form element, part of a data table structure, list etc. In addition, several keys are captured by the assistive technology and are not processed by the browser. These allow navigation by headings, lists, links, tables, form elements and others. Usually, these are done via single letters. The visual focus may or may not follow the virtual cursor onto focusable items, depending on the assistive technology in use and its settings.
Forms mode or focus mode: This is a mode where the user interacts with elements that accept a form of data entry. This may be via entering text, checking a check box, selecting one of several possible radio buttons, or making a selection in a select element. This mode is either invoked by putting the virtual or browse focus onto such an element and pressing a key (usually Enter), or by the assistive technology switching to this mode automatically when the virtual focus encounters such an element. Others may only activate this mode automatically when specifically using the tab key. In this mode, all keys are passed through to the browser. It is as if you were sitting in front of your browser using it with the keyboard, and don’t have a screen reader running. Likewise, if the application focus leaves such an element that supports or requires direct keyboard interaction, if it was switched on automatically, it will be switched off and the user returned to browse/virtual mode. Note: Some elements like buttons and links do not require the user to switch into focus or forms mode, because for efficiency, screen readers allow activation of these elements directly from virtual/focus modes.

The challenge is that you may be creating widgets that require you to force the user into direct interaction with the browser. You know that your widget can best be used via the keyboard if the user is not in virtual mode. In addition, you know that you have no classic document content to display, but only use widgets and provide all necessary context through them. This is what role “application” is for. It is under your control whether the user is being thrown into focus mode once your widget gains keyboard focus. Also, contrary to standard focus mode, if an assistive technology encounters an area that is marked up with role “application”, it is usually not so easy to manually exit out of that mode to review the surrounding content in browse mode.

So when should I use it, and when not?

You do not use it if a set of controls only contains these widgets, that are all part of standard HTML. This also applies if you mark them up and create an interaction model using WAI-ARIA roles instead of standard HTML widgets:

text box. This also applies to password, search, tel and other newer input type derivates
textarea
check box
button
radio button (usually inside a fieldset/legend element wrapper)
select + option(s)
links, paragraphs, headings, and other things that are classic/native to documents on the web.

You also do not use the “application” role if your widget is one of the following more dynamic and non-native widgets. Screen readers and other assistive technologies that support WAI-ARIA will support switching between browse and focus modes for these by default, too:

tree view
slider
table that has focusable items and is being navigated via the arrow keys, for example a list of e-mail messages where you provide specific information. Other examples are interactive grids, tree grids etc.
A list of tabs (tab, tablist) where the user selects tabs via the left and right arrow keys. Remember that you have to implement the keyboard navigation model for this!
dialog and alertdialog. These cause screen readers to go into a sort of application mode implicitly once focus moves to a control inside them. Note that for these to work best, set the aria-describedby attribute of the element whose role is “dialog” to the id of the text that explains the dialog’s purpose, and set focus to the first interactive control when you open it.
toolbar and toolbarbuttons, menus and menu items, and similar

You only want to use role “application” if the content you’re providing consists of only interactive controls, and of those, mostly advanced widgets, that emulate a real desktop application. Note that, despite many things now being called a web application, most of the content these web applications work with are still document-based information, be it Facebook posts and comments, blogs, Twitter feeds, even accordeons that show and hide certain types of information dynamically. We primarily still deal with documents on the web, even though they may have a desktop-ish feel to them on the surface.

In short: The times when you actually will use role “applications” are probably going to be very rare cases!

So where do I put this thing?

Put it on the closest containing element of your widget, for example the parent div of your element that is your outer most widget element. If that outer div wraps only widgets that need the application interaction model, this will make sure focus mode is switched off once the user tabs out of this widget.

Only put it on the body element if your page consists solely of a widget or set of widgets that all need the focus mode to be turned on. If you have a majority of these widgets, but also have something you want the user to browse, use the role “document” on the outer-most element of this document-ish part of the page. It is the counterpart to “application” and will allow you to tell the screen reader to use browse mode for this part. Also make this element tabbable by setting a tabindex value on it so the user has a chance to reach it. As a rule of thumb: If your page consists of over 90 or even 95 percent of widgets, role “application” may be appropriate. Even then, find someone knowledgeable who can actually test two versions of this: One with and one without role “application” set to see which model works best.

NEVER put it on a widely containing element such as body if your page consists mostly of traditional widgets or page elements such as links that the user does not have to interact with in focus mode. This will cause huge headaches for any assistive technology user trying to use your site/app.

Some examples

The example that prompted me to write this is the newest version of the layout of Gmail. Gmail treats the whole thing as role “application”, causing the user to tab a zillion times before actually getting to the inbox message table. If they had used the role properly, the users could press t in their screen reader once and jump to that table right away instead of tabbing 30 or 40 times. Yes, Google do provide us with keyboard shortcuts j and k. Unfrortunately, aside from the fact that you have to know about them in the first place, they only work in Chrome and ChromeVox, but no other browsers. Despite what Google themselves call it, Gmail is, below the surface, still strongly document based and thus many traditional interaction modes do still apply here.

An example where roles “application” and “document” are really used wisely is the current Yahoo! mail web interface. The table where the messages are being displayed in a list is marked up to be an “application”, because the arrow keys are used to navigate between messages, enter opens one etc. Once a mail is being displayed, everything around the actual mail header and text is an application, but the mail header and text are a document, so role “document” is used and initial focus is put there so the user can immediately start reading their mail in a familiar browsing fashion.

funny disclaimer: Yahoo! do not pay me for constantly calling them out as a good example of an accessible web app. They just did a bang-up job, that’s all!

Closing comments

If you have questions about this, feel free to post them here on the blog, I’ll do my best to answer them and also incorporate answers to updates to this post. You can also find the Google Group free-aria and discuss questions there with other web developers, standards experts and users. This is an important topic that, if done right, can provide all your users with a rich and pleasant experience, but if done wrong, can also cause headaches, complaints, and cause your web app to be less likeable by a sizeable number of users.

So use role “application” only if you absolutely have to, and tests show that this provides the better interaction model! Use it wisely when you do it, it’s worth the effort!

Update February 7

I’ve incorporated comments that were posted to the original version of this blog post into the post, making the statements even stronger hopefully. Thanks to Jamie for pointing out a couple of very important points that make the point against using role “application” in most cases even stronger!

Just Browsing: There is War!

Arne Seib — Mon, 06 Feb 2012 19:33:30 +0000

No, I don’t want to write this article. Not at all. But I have to.

I recently had to look up a phrase that didn’t mean anything to me so far, the phrase “flame war”. Wikipedia defines “flaming” as “hostile and insulting interaction between Internet users”. So when I learned the meaning of “flame wars” my first thought was: “Ok, I understand, it has something to do with religion.” Usually discussions between religions are hostile and often insulting, and in all cases they state that one party is right and the other is wrong. Regarding religions this might be the only way of discussing things, since religions don’t have solid facts that can be contributed as arguments. They are based on beliefs and opinions, and only some religions derive these rules and opinions from observations and experiences (usually the ones that don’t go into flame wars).

Unfortunately the flame war I was dragged in was not about religion, it was about programming – but it was fought how only religious discussions are fought. I was pretty startled when I found myself in the middle of such a war, although I never was a religious person! Thank God(!) a wise man from a foreign country (Great Britain) knocked on my door and stopped me before someone could chop off my head, so here a short warning to you all: You can’t win with those people. Don’t get into a fight. Shrug your shoulders and mind your own business.

But what was all this about? Well… let’s see.

There is a very basic fear that all animals share: The fear of the unknown or the incomprehensible.

If you are the father or mother of a child and you belong to a ethnic minority you might know what I’m talking about. Your child looks different. It may speak a bit different. Maybe it plays different games. Some of your child’s classmates might be curious and ask questions like “Why do you always wear these funny rings around your neck?” or “What does your name mean?”. Others (usually the ones that are more bound to instincts than to thinking) might react with rejection or even aggression. They follow their fundamental fear, and, in the case of aggression, also the rule “Kill it before it kills us”. Okay, that might be a bit strong, but basically it goes like “I don’t know what the foreign child is doing, so I don’t like it, it might be (no, it is!) evil.” So in the end non-understanding results in rejection.

And what does that have to do with programming?.

Sometimes programmers behave like children — or animals, or bigots. Sad, but true. For example when they state that “their” programming language is the only language and all others are stupid. You might then ask them “And why you say feature-A of language-A is evil?”. And you get the answer — usually after some deeper digging — “Because I don’t like it”, which then (again after some discussion about the benefits of feature-A) turns out to mean “I don’t (totally) understand it”. This is sad. Not only because it doesn’t do justice to those “other languages”, but also because these people are limiting themselves and their advancement.

Also a very childish behaviour is their effort to find something where other languages are not as good as their own favourite language. When they find it, they behave like children who are bullying another child with a disability. “Haha, you have to indicate the type of a variable, I can pass anything to my function! Retype, retype!” A good programmer on the other hand will always be interested in finding the best solution for his problem, and he will be excited to learn new techniques and features that allow him to get better, especially when he discovers the weaknesses of his own favourite language.

All in all this kind of informatics chauvinism or IT-racism it immature, self-limiting and results in unnecessary flame wars that have no winner.

To say it in religious words: The best way to get an impression of what God might really be is to have a look at as many religions as possible, because God is everything. Whenever you exclude something you won’t get the whole picture.

A small joke to finish this:

A priest, a minister, and a rabbi were all sitting at a table, finishing dinner and discussing theology. Suddenly an angel appeared before them. “I have been sent to grant each of you one wish,” he said. “Who will go first?”

The Catholic priest stood up. “I wish for the destruction of all Protestants!”

Then the Protestant minister bolted up. “I wish for the destruction of all Catholics!”

The rabbi kept seated, so the angel asked, “How about you? What do you wish for, rabbi?”

The rabbi answered, “Well, if you’re going to grant their wishes, I’ll just settle for another cup of coffee.”

Irina Sandu: Mobile Q4 2011 in review – Apple, security and privacy, Amazon

irina — Mon, 06 Feb 2012 17:41:00 +0000

Apple had an unusual quarter, which resulted in record revenues for the company, due to the discontinuation of its regular sales cycle which begins with a new iPhone version launch in Q3 of every year. The iPhone 4s release at the beginning of Q4 maximized results for the quarter by its combination with the second biggest sales period of the year: the holiday season. Rumours to the cause of the delay varied, the one with the most pick-up being that Apple had initially designed the new iPhone version to not contain an operator-provided SIM card, but have the phone take over all of its functions; a move which was rejected by carriers and compelled the fruit company to keep the old standard in place. The main innovation of the iPhone 4S is Siri, a new iteration for voice recognition software that has the opportunity to become a new mainstream input method as the technology strives to mature while being developed by multiple players in different tech industries. Results placed Apple as the most probable top smartphone vendor for the quarter, with 37 million iPhones sold, only an estimated 0.5 million less than its closest competitor, Samsung. For Q1 of 2012, iPhone sales are expected to follow the traditional annual slowdown after the holiday season, but we will see a spike in iPad sales, as the new version is expected towards the end of the quarter.

♦

Security and privacy has always been a sensitive topic on mobile and the increase in capabilities of the average device expands the interest for and possibilities to create concerns among consumers. The profile of the mobile phone as a closely personal device demands for strong consideration of security and privacy and raises a lot of concern when breaches are discovered. Such was the case with the discovery of the Carrier IQ software on Android and iOS smartphones, an app which was typically installed by OEMs or carriers and had the ability to send detailed information on phone activity to a third-party. The press coverage triggered several class-action lawsuits against phone makers and carriers and a bill concerning the installation of monitoring software on mobile phones to be proposed in the US.

♦

Amazon launched its first Android-based tablet in the US, the Kindle Fire, which achieved impressive sales of 5 to 6 million devices in the first quarter after launch. Reviews of the device were mixed and positioned the tablet as offering an average experience in capabilities and user experience for the segment. Its success is partly explained by the affordable price, a lot lower than tablets with similar hardware specifications and which causes Amazon an estimated $50 dollars net loss per each device sold. The company’s strategy to make up for the low price and turn the venture into profit is through revenue for content on the device, a strategy which is still to be proven feasible, as increase in media sales for North America for Q4 was only 8%.

QMO: WebQA ‘Live’ Test Day – Thursday, February 23rd, 2012

Dave Hunt — Mon, 06 Feb 2012 16:34:50 +0000

We’re inviting web testers from all skill levels to our San Fransisco space to learn hands-on how we test our websites! Bring your laptop, pick a project that interests you, and work alongside our WebQA team as we push our web testing to the next level! If you’re an expert in performance testing, why not find out how we do functional testing? Even if you’re completely new to web testing, we’ll help to get you up and running. Become a Mozilla contributor and help us make the web a better place!

Here are a few of the projects that we’ll be offering:

Automated mobile web testing – writing WebDriver tests for mobile, using emulators, devices, and boards
Migrating projects from Selenium RC to WebDriver – find out what we’ve learned, and help us to migrate more projects
Integrating with BrowserID – A new form of online identity, as sites adopt it, we need to be able to automate with it
Increasing our automation coverage – Help us to add new tests to our mozilla.com and Mozilla Developer Network test suites
Expand our test templates – Due to the velocity of engagement projects we’ve created automated testing templates, with your help we can make these even better
Pay off technical debt – Almost every project accrues a technical debt, and this is a perfect opportunity to pay some of this off
Automated test maintenance – Investigate failures with us, fix some tests, or raise bugs and mark the tests as expected to fail
Improve documentation – A project is only as good as it’s documentation

There will also be an opportunity to learn about the tools we use:
NetSparker, Power Fuzzer, JMeter, Selenium, pytest (and various plugins), BeautifulSoup, git, and more!

This event will be limited in space, and you will need to bring your own laptop to work on. If you’re interested in attending please RSVP to the event here.

When: February 23, 2012.

hacks.mozilla.org: Tantek Çelik about the importance of Web Standards

Tristan Nitot — Mon, 06 Feb 2012 16:23:32 +0000

This is the fourth installment of Mission:Mozilla, a series of interviews that link Mozillians, the technology they produce and the Mozilla mission. This time, We’re interviewing Tantek Çelik, a long-time Web standards contributor. He started working on web standards at Microsoft in 1998, while leading the development of Tasman, the IE Mac rendering engine, and subsequently founded independent efforts like microformats.org, BarCamp, and most recently, IndieWebCamp.org.

Tristan – Hi Tantek, could you introduce yourself? (I could point our reader to your Wikipedia page, but it seems a bit out of date).

Tantek – I’ve been passionate about web standards since being inspired at the level of collaboration among different companies, cultures, individuals at my first W3C CSS&PF WG meeting May 1998 in Paris. My interest in standards as building blocks started much earlier with many childhood hours spent building things with LEGOs.

Tristan – Ah, LEGOs! I have fond memories of them, particularly LEGO technic! They’ve inspired so many geeks that they somehow should be credited for their work in W3C specs, don’t you think? ;-)

Tantek – Indeed I think LEGOs have inspired many an engineer. Simple pieces that could be combined in numerous ways and built into amazing unique and creative structures.

Tristan – Sounds like a good description of Web technologies to me! Who was your employer back then?

Tantek – I was working for Microsoft at the time, having joined the Macintosh Internet Products Group in 1997. I started work on Macintosh Internet Explorer (MacIE) in mid 1997 with mostly bug fixes and improvements in CSS support which incrementally made their way into MacIE 4. It was soon clear though that we needed a fairly big overhaul to implement better CSS support. Soon after I joined standards discussions in the W3C.

Tristan – It’s a little known fact, but IE Mac was really raising the bar when it came to CSS compliance. It was a time where few people cared about Web standards. I was at Netscape back then, and you at Microsoft. It was amazing to see a team trying to push Web standards on the other side of the fence!

Tantek – When I was made the developer lead for the MacIE rendering engine, it wasn’t immediately obvious to me what we should focus on, so I decided to interview web design firms in San Francisco and just ask: “Hi I’m with the Microsoft MacIE team. What would you like to see in terms of standards / rendering support in the next version of MacIE?” The answers were loud and clear: dependable standards support! In particular: reliable and ideally complete CSS support, “XML support” (whatever that meant), and better Javascript/DOM support. A few specifically asked for PNG support. Those interviews drove the priorities of what became Tasman, the new rendering engine for MacIE5 which itself in the process got renamed to Internet Explorer 5 for Macintosh (IE5/Mac). Little did I know at the time that such a focus on getting web standards right would come as a surprise to others.

Tristan – And now, a few years down the road, we’ve seen how Web standards have made the Web what it is today, but they’re also something that Web browser vendors are heavily investing on! What do you do for Mozilla today? Why should Web developers care?

Tantek – I joined Mozilla in May 2010 as Web Standards Lead and I’m excited to be working with so many people passionate about standards. In an organization with numerous talented web standards contributors, in addition to editing/iterating specifications, my role is often more of coordination and collaboration, making sure that folks who care about particular standards find each other and work together. One key thing I’ve created and driven in Mozilla is the open documentation of our standards participation, in a public place where not only we (Mozillians) can find each other, but web developers in general can see how much effort Mozilla and individual Mozillians put into web standards.

Tristan – I have the impression that Mozilla does not get the share of credit we deserve when it comes to our work on standards. Don’t you agree?

Tantek – As someone who’s been involved with web standards for over a decade, I’ve had a deep respect for Mozilla’s involvement with web standards for quite some time. However I do think that recognition can easily be forgotten outside of standards circles. I think the web community as a whole greatly underestimates the longevity, depth, and dedication of Mozilla’s contributions to web standards.

Tristan – Where do you think Mozilla particularly shines?

Tantek – One thing that’s always impressed me about Mozilla’s commitment to web standards is the level of quality and thoroughness that Mozilla places into implementations. In my experience, historically Firefox has had the highest fidelity handling of various CSS properties for example, focusing more on getting things precisely right rather than shipping quick implementations that may only cover common or 80% cases.

Second, Mozilla works far more in the open, early and often, than any other organization. For example, we do nearly all our project work on open wiki pages on wiki.mozilla.org. I even keep my own Mozilla projects list on an open Mozilla wiki page. It makes it really easy to answer when people ask me what am I working on these days.

Tristan – I agree with you. I sense that Mozilla tends to do the right thing, rather than the thing that makes us look good. Can you give an example why do Web standards matter?

Tantek – The browser compatibility tax. When the Web Standards Project started in 1998, they raised the real and painful issue of the “browser compatibility tax” that developers had to pay when developing web sites. No matter what standard a web author would use, they’d have to spend potentially 50-75% of their time purely on making their code work in multiple browsers, sometimes having to write multiple versions of their markup and style sheets and then use fragile user-agent string tests to serve different content (a bad habit that still persists to this day). Much of this was due to the abysmal standards support in 1990s browsers.

Web standards are an agreement between authors and browsers: if the author writes valid code (whether HTML, CSS, or JS), the browsers agree to render and execute it predictably and according to the standards. Without standards, web authors end up wasting their time coding for one browser at a time (typically focusing on whatever is the popular browser that year), and browsers developers end up wasting their time writing code fixing one site at a time.

Tristan – And if we want the Web to be the platform of choice for all kind of developers and all kinds of applications, from desktop to mobile, we need to remove this “browser compatibility tax”.

Tantek – Yes. It’s up to all of us as browser implementers to provide strictly correct implementations of web standards for authors to use, and for implementers to openly propose and test innovations in web standards.

Tristan – what’s your biggest concern about Web standards?

Tantek – My biggest concern about web standards can be summed up in four words: “Best Viewed In [...]“ where the fourth word can be filled in with a different browser nearly every year. Anything that encourages web authors to focus on a single browser (or browser engine) to the expense of other browsers hurts the web. It’s also short-sighted – next year all the browsers will change and what was “best” last year is not the same this year, even newer versions of the same browser!

Worst of all is when browser vendors themselves either encourage or outright publish “best viewed in” content themselves, thus setting a bad example for web authors.

Judge for yourself – whenever you see a site purporting to show-off or demonstrate web standards, if the site ever gives you an excuse like “Please use browser X to view this” then they’re misbehaving. Standards demonstrations should simply state the standards they require, and then link to test suites (developed in standards bodies) for you to check your own browser.

And “Best Viewed In” is just one of several concerns.

There are many difficult challenges to open web standards that we must acknowledge and continue fighting hard to overcome. Challenges like patents that may hurt Touch Events, devices that only effectively support a single browser engine, and when one or a small number of companies decide to dictate de-facto standards through “delayed open” tactics.

Tristan – What’s the most exciting thing going on in the world of Web standards these days?

Tantek – So many things to choose from! I think the most exciting thing about web standards these days is the unprecedented level of intense interest and collaboration across numerous companies on the open web platform built on web standards. There’s a rising culture of placing importance on the open web, and I think we have Mozilla to thank for keeping that flame alive for so long and setting an ever higher bar for how to best work openly on open web standards.

The Mozilla Manifesto provides an excellent set of principles for how to do so. I think what’s particularly important is to keep evolving openness, and Mozilla encourages community members to contribute their own views on how and why to work openly. Here is some more on the subject:

Tristan – Thank you very much for your time Tantek, and keep up the good (and open) work!

Web FWD: Become a WebFWD Affiliate!

Mon, 06 Feb 2012 16:00:48 +0000

To spread awareness of our growing global program, we rely largely on our Scouts, Mentors, Partners — and you! We are thrilled to announce that now you can support WebFWD directly and stay connected by becoming a Mozilla WebFWD Affiliate.

How does this work? Good news: it’s super easy. Just sign up to become a Firefox Affiliate. Once you’re signed up (BrowserID makes this part quick and simple), you can select the WebFWD logo in the “Mozilla” category, pick the logo size that works for your blog, website or personal page, and grab the custom HTML code to add to your page.

And ta-da: by adding this badge you become a WebFWD affiliate, increasing awareness of our open innovation program! The code ensures we can stay aware of all the love (and traffic) you send our way. It always comes back :) .

Jess Klein: On Integrating Learning

noreply@blogger.com (Jess) — Mon, 06 Feb 2012 15:51:07 +0000

Over this past weekend I went to an exhibition at the Brooklyn Museum of Art called Hide and Seek- it was a fantastic show exhibiting American work focusing on gender and identity. I highly recommend it. However, as I was going around the exhibition, I came upon this sign:

The sign marked the entry to a room devoted to didactic content related to the themes and subject matter in the exhibition. While normally I am such a huge fan of how innovative and creative the Brooklyn Museum is with providing interactive and accessible learning tools in their exhibition spaces, I was a bit put off by this. First of all, no one was entering this space (except my colleague Atul- who I think falls under that small percentage of self proclaimed "information geeks"). I don't think that seeing the words "Educational Resource Space" would compel anyone to enter that area. The exhibition had extraordinary content with the lush and often times shockingly graphic art and photography- why didn't they exploit the opportunity right then and there? Yes, there were the typical didactic labels filled with tombstone information- however that kind of just scratched the surface of the potential conversation.

This experience got me to thinking a bit about the work that I am doing at Mozilla. As I've said numerous times, I am not about hiding the learning or sugar coating it- but I am interested in integrating it into the activity that the participant and, in this case "viewer" is passionate about. When we build software and tools- we should be thinking about how we can embed the learning into the experience and not make it something that you need to seek out as an afterthought. This is important for many reasons- but on a very practical level the reason to do this is because you have a captive audience!

As I keep iterating on my prototypes and participate in the Open News sprint this week- I am going to try to keep this in mind. But, it is something that Mozilla is committed to, by design. By design, people like Atul and I work on the same team- and we work with community members who are skilled in teaching and education. We have embedded the learning in our work structure, but now we need to constantly keep ourselves in check that "learning" is not something that happens just in a special space in our projects that is devoted to "educational resources."

Henrik Skupin: FOSDEM 2012, Add-on SDK, and slides for Mozmill CI

Henrik Skupin — Mon, 06 Feb 2012 15:40:58 +0000

Over the last weekend I had the pleasure to participate in the Free and Open source Software Developers’ European Meeting – aka FOSDEM – in Brussels, which is an annual conference for open source projects and their enthusiastic communities. It’s not only fascinating to listen to scheduled talks, but also to meet fellows again who I haven’t seen for mostly a year or even longer.

As every year I have spent a bit of my time before the event to prepare a schedule including interesting talks and other organizational stuff. But as it has been turned out again, setting up a schedule for talks is useless for me, because I would sit most of the time in the Mozilla DevRoom anyway. There are way too many interesting presentations and discussions that it is hard for me to leave.

This year some bits were different. Given my cold I was not able to participate in the Beer Event in the Delirium Cafe. It’s usually the perfect initial come together of this conference to greet people and have the first conversations. I kinda missed it, but the remaining work for this week did a good job in not letting me think about if for so long. The other news we noticed with the arrival at the campus of the University Solbosch. Surprisingly the locations have been modified a bit to give everyone more space. The biggest change definitely was the move of the booths to another building, which wasn’t that close to the rest of the areas of interest. So I headed over only once to check our Mozilla booth. IMO we haven’t had such a great location this time but given by our staff a lot of people stopped by already. While checking the other booths I also found the one of the Jenkins project, where Kohsuke Kawaguchi – the creator of Jenkins (formerly Hudson) – was able to help me with all of my questions. I call this a success – thanks Kohsuke!

As my personal highlight I had an own talk about Continuous Integration with Mozmill scheduled on Sunday at noon. It went pretty well and I got some positive feedback. If you wasn’t able to make it, you can check my slides here:

Continuous Integration with Mozmill

View more presentations from Henrik Skupin

The most impressive conversation and follow-up work happened definitely with the guys from the Mozilla Add-on SDK project. Starting from my quick question about a foreseeable support for Thunderbird, it ended-up in a lot of discussions and a final hacking session at Sunday afternoon, which I sadly wasn’t able to attend. So I’m absolutely interested in the results. Oh, and while traveling back home I have spent about an hour to contribute my first patch to the project, which will let the builder add contributor names to the extensions install.rdf file.

All in all it was a stunning weekend and I hope to be able to attend it next year again. So a big thanks to Benoit and the Belgian community for taking care of the organization!

QMO: Firefox Beta for Android Test Day – Friday, February 10th, 2012

Aaron Train — Mon, 06 Feb 2012 15:31:37 +0000

This upcoming Friday, we would love for you to solicit your support towards testing and contributing to the process of qualifying the new version of Firefox Beta for Android on the Beta channel as part of our Rapid Release testing cycle.

This event is open to all those interested: newcomers, experienced testers, experienced developers, and anyone interested in testing and using Firefox on Android.

We would like for you to use the new version of Firefox on your Android phone, and take a close look at the latest Beta product in order to assist us in identifying any noticeably major issues found, and ensure that all feature functionality that is included in this upcoming release is on its way to a feature and testing complete state. We will also be looking at website compatibility, and device compatibility. No testing experience is required.

To cover the work throughout the whole day we have created an EtherPad test-plan. Please feel free to read and use it as a companion during the testday event. There will be moderators at hand in the IRC channel: #testday, to answer any questions you have.

Together with your help we want to make this testday a success and ensure the high quality of Firefox Beta for mobile devices for all of our users world-wide. If you have time on Friday, February 10th, 2012, please join us on IRC, we will have Mozilla community and testers on hand to help answer any of your questions.

Your testing and feedback is highly valuable, and we hope to see you attend our testday event.

When: February 10, 2012.

Henri Sivonen: Accept-Charset Is No More

Mon, 06 Feb 2012 14:41:39 +0000

Now that Firefox 10 has been released, ~~none of the major browsers send~~ only Chrome sends the Accept-Charset HTTP header.

During the Firefox 4 development cycle, I noticed that IE~~, Chrome~~ and Safari were not sending the Accept-Charset HTTP header in their HTTP requests. This meant that the Web had to work even without browser sending that header.

It was already obvious that Accept-Charset was obsolete as a feature and was a waste of bytes in each HTTP request. If your server has the capability to vary what character encoding it uses, it could use UTF-8. All browsers support UTF-8. There is no way for any non-UTF-8 encoding to represent something more, since everything gets converted to UTF-16 internally. Thus, the browser and the server negotiating a suitable encoding is pointless.

There was indication that Opera was going to drop Accept-Encoding and indeed they have dropped it by now. In the case of Firefox, the change was not allowed in Firefox 4. Ms2ger removed Accept-Charset and landed the code for Firefox 6.

However, it turned out that Yahoo! Search and Yahoo! Babelfish malfunctioned when the browser identified itself as Firefox but did not send Accept-Charset. Since the sites worked in IE~~, Chrome~~ and Safari, they obviously had to have code paths that functioned without Accept-Charset. However, the code paths were conditional on the UA string instead of the presence of Accept-Charset. Sigh.

To give Yahoo! time to fix their stuff, the change was backed out before release from Firefox 6. And then Firefox 7. And Firefox 8. And Firefox 9. The change was finally shipped in Firefox 10. Yahoo! Search had been fixed. Yahoo! Babelfish is still broken as of 2012-02-06.

Anyway, now none of Firefox, Opera, Safari~~, Chrome~~ or IE send the Accept-Charset header. Yay for smaller HTTP requests.

What Can We Learn?

As a server talking to a browser, always use UTF-8. No exceptions. Use the lang attribute for CJK disambiguation.
It is hard to take cruft out of the HTTP request boilerplate. Resist the urge to put new cruft there.
It is a bad idea to assume that a certain feature is present because the UA string looks a certain way. Check for the presence of the feature instead!
If you defer a browser change in order to give a site the time to make a trivial adjustment, you may end up deferring the change many times.

Correction About Chrome

Contrary to what I originally wrote, Chrome still sends Accept-Charset as of 2012-02-06. Right before I wrote this post, I tested something encoding-related in Chrome, thought I had tested this in Chrome, too, but it turns out I only tested this in Safari 5.1.3, IE9, Firefox 10 and Opera 11.61 and failed to test Chrome. How embarrassing. Sorry.

Gervase Markham: Disabling Private Browsing Mode in Firefox

gerv — Mon, 06 Feb 2012 13:24:56 +0000

This subject has been discussed before on this blog. I support the right of parents to review what their children have been looking at, both morally in terms of my understanding of the way God has given parents authority over their children, and for the pragmatic reason that it’s likely that, with such an ability, they will give their children greater access to the web than they would otherwise have. So I think it should be possible to disable PBM. However, I’m not really interested in having that discussion again – this post is about the best way to do it, not whether it’s a good idea.

William Wood has written a program, “Incognito Gone”, which turns off private browsing or the equivalent in Chrome, IE and Firefox. However, his page says:

Note: While Incognito Gone completely removes the private browsing function from Google Chrome and Internet Explorer, in Mozilla Firefox only the option for private browsing is removed. In other words, if you know the keyboard shortcut for private browsing in Firefox, it is still available.

Technically, Chrome and IE support this disabling using a registry option and, if your Windows computer is set up correctly with user accounts for each person, then this is an effective method, and it’s what William’s program uses. For Firefox, he just drops in a userChrome.css to hide the menu item, which is clearly suboptimal.

Is it possible to have an “uninstallable extension”, under the same conditions (user account separation) as IE and Chrome have “unchangeable registry entries”? If so, that seems like it would provide parity with Chrome and IE.

If we added a private browsing pref, does “pref locking” still work, and could that be used? There are docs about it on the web, but no clear info as to whether it currently works and can be done in a non-defeatable manner. Are any EWG participants using it?

Dave Hunt: Automating BrowserID with Selenium

Dave — Mon, 06 Feb 2012 12:48:45 +0000

BrowserID is an awesome new approach to handling online identity. If you haven’t heard of it then I highly recommend reading this article, which explains what it is and how it works. Several Mozilla projects have already integrated with BrowserID, including Mozillians, Affiliates, and the Mozilla Developer Network.

With all of these sites now integrating with BrowserID (and more on their way) we needed to add support to our test automation to handle the new sign in process. Initially we started to do this independently in our projects, but the thought of updating all of our projects whenever a tweak was made to BrowserID was daunting to say the least! For this reason I have created a project that contains a page object model for BrowserID. This can be included in other projects as a submodule and then updated and maintained centrally.

The new project is called ‘BIDPOM’ (BrowserID Page Object Model) and can be found here. It currently only contains a page object for the Sign In page, however this currently meets the needs of the automation for projects that have integrated with BrowserID. As we have a mix of projects using Selenium’s two APIs (RC and WebDriver), it was necessary for BIDPOM to support both.

By adding BIDPOM as a submodule, we can easily pull the BrowserID page objects into our automation projects and reference them in a very similar way to the main project’s page objects. We can also update the version of BIDPOM simply by updating the git link and updating the submodule. What’s even better is that our continuous test builds running in Jenkins automatically initialise and update the submodule for us!

I hope that in addition to being a dependency for our own automation projects, this page object model can be utilised by others wanting to create or maintain automated tests using Selenium against sites that adopt BrowserID. If you would like to start using BIDPOM then I have provided below a guide to adding the project as a submodule to an existing git repository.

From within your project, add the BIDPOM project as a git submodule:

cd ~/workspace/automationproject
git submodule add git://github.com/davehunt/bidpom.git browserid

This will add an entry to .gitmodules and clone the BIDPOM project to the browserid subdirectory. It will also stage the new gitlink and .gitmodules items for commit.

You can now commit these changes to your project’s repository:

git commit -m 'Added BrowserID page object model as submodule.'

Before you can test the new submodule you will need to run the following command to copy the contents of .gitmodules into your .git/config file.

git submodule init

Now you can test the submodule by deleting the browserid directory and allowing it to be recreated:

rm -rf browserid
git submodule update

The BIDPOM project should be cloned to the browserid directory.

You will now be able to integrate your project with BrowserID! Here follow a few examples of how to integrate your project.

Example: Short sign-in using Selenium’s RC API

...
selenium.click('id=login')
from browserid import BrowserID
browser_id = BrowserID(selenium)
browser_id.sign_in('testaccount@example.com', 'password')
assert selenium.is_visible('id=logout')

Example: Long sign-in using Selenium’s RC API

...
selenium.click('id=login')
from browserid.pages.rc.sign_in import SignIn
signin = SignIn(self.selenium, self.timeout)
signin.email = 'testaccount@example.com'
signin.click_next()
signin.password = 'password'
signin.click_select_email()
signin.click_sign_in()
assert selenium.is_visible('id=logout')

Example: Short sign-in using Selenium’s WebDriver API

...
selenium.find_element_by_id('login').click()
from browserid import BrowserID
browser_id = BrowserID(selenium)
browser_id.sign_in('testaccount@example.com', 'password')
assert selenium.find_element_by_id('logout').is_displayed()

Example: Long sign-in using Selenium’s WebDriver API

...
selenium.find_element_by_id('login').click()
from browserid.pages.webdriver.sign_in import SignIn
signin = SignIn(self.selenium, self.timeout)
signin.email = 'testaccount@example.com'
signin.click_next()
signin.password = 'password'
signin.click_select_email()
signin.click_sign_in()
assert selenium.find_element_by_id('logout').is_displayed()

For the latest documentation on the BIDPOM project refer to the github wiki.

Ludovic Hirlimann: Want to understand certs ? SSL and friends ?

Ludovic Hirlimann — Mon, 06 Feb 2012 12:26:02 +0000

My friend kaie made a very nice and explanative talk at fosdem on the subject. It's now available for reading in pdf at http://kuix.de/fosdem2012/fosdem-2012-talk-kaie.pdf

Mozilla Add-ons Blog: Mobile Add-on development using the Add-on SDK

Jeff Griffiths — Mon, 06 Feb 2012 12:07:44 +0000

For this post, please welcome guest blogger and SDK developer Matteo Ferretti who has been hard at work porting the SDK to work with the new native version of Mobile Firefox.

Getting Started

Add-on SDK version 1.5 is due to be released on February 21st, and we're pleased to announce that this version will introduce initial support for creating addons for the new native version of Firefox Mobile (codename "fennec").
Mobile support is still experimental and is currently focused on addons using the SDK's page-mod module to alter and interact with web pages.

If you're interested in trying this support out now, you can do so by checking out the ‘master’ branch of the addon-sdk repository:

git clone git://github.com/mozilla/addon-sdk.git

Alternatively you can just download a zip archive of the current master:

https://github.com/mozilla/addon-sdk/zipball/master

Developing an add-on for Firefox Mobile with the Add-on SDK is very similar to the desktop. If you're not familiar with Add-on SDK development process, you can take a look here. It helps but is not mandatory for this tutorial.

Getting set up

In addition to having the correct version of the SDK, there are some additional requirements:

you need to have an Android device connected to your computer via USB
on the Android device, you need to install a Nightly build of Firefox Mobile.
you need to download and install the Android SDK, including the SDK Tools. Specifically, the SDK requires that you have installed the 'adb' command-line tool.

Please see this detailed tutorial by Aaron Train for more information on installing and configuring the Android SDK.

Now you're ready to write the classic "Hello World" example!

Hello, Fennec!

Firstly, be sure that you have connected your device to your computer. You can check it running from a shell the following command:

adb devices

Then, be sure that you don't have any Firefox Mobile already running. That is important because the Add-on SDK will run your add-on using a temporary firefox profile for development, not the default one. If Firefox is already running, you can quit Firefox by opening the application menu, selecting 'More', then selecting 'Quit'.
Don't worry, if Firefox is running the Add-on SDK will clearly warn you.

Now open a shell, navigate to the Add-on SDK root directory, and execute:

source bin/activate

This will activate the SDK's environment and allow you to run the cfx tool from the current shell prompt nomatter what directory you are currently in..

Change to another directory and then create a directory called hellofennec. Keeping your add-on code outside the SDK is good practice. Navigate to that directory and run cfx init to create a new addon:

mkdir hellofennec
cd hellofennec
cfx init

With a text editor or IDE of your choice, open lib/main.js, and replace its contents with the following:

console.log("Hello, Fennec!");

Save it. You're ready to run it on your device using the following command:

cfx run -a fennec-on-device -b ~/path/to/adb --mobile-app fennec --force-mobile

And yes, compared to the desktop version the mobile version needs more arguments. You can learn about all the cfx's arguments just run it without any parameters, but let's have a quick look about what they means in this context:

-a, –app : specify the application that runs the add-on, in this case "fennec on device".
-b, –binary : is mandatory for fennec-on-device app. SDK needs to know where you have installed the adb tool that is installed with the Android SDK in order to communicate with your device. So, replace this value with the right path where you have installed the adb platform tool.
–mobile-app : is the name of the Android intent. If you have only one Firefox Mobile version installed on your device, you can omit this option. The value for nightly is fennec, for aurora this is fennec_aurora, for beta this is firefox_beta and for release this is firefox.
If you have a Fennec's custom build on your device, the intent's name is fennec_<your_username> by default.
–force-mobile : this flag will be removed when the mobile's support will be stable and not experimental anymore.

When you execute the command the first time you'll see a message like this:

No 'id' in package.json: creating a new ID for you.
package.json modified: please re-run 'cfx run'

Run the command again, and it will run Firefox Mobile on your device with your add-on installed.

Congratulations! You have made your first step in mobile add-ons development with Add-on SDK!

Hack the web

As I said previously, Add-on SDK provide a minimal support for mobile at the moment, focused mainly on page-mod. In short, they are add-ons that can modify any — or a specific — web pages loaded by the browser.

On mobile this is very handy. For instance, you can optimize a website that it wasn't designed for mobile devices, improve the readability, or adding unique functionality.

For this tutorial I made a simple add-on that "mod" the famous penny-arcade.com website. You can check it out from github:

git clone git://github.com/ZER0/penny-arcade-comics.git

Alternatively, you can download it as zip archive.

What it does is simple: when you're on the penny-arcade.com homepage or reading a news post, switching from portrait to landscape will display the webcomics related to that news, without clicking a link and zooming (landscape fits more the format of penny-arcade comics than portrait, and portrait is more suitable to reading news). Switching back from landscape to portrait will hide it again.

A deeper look

So, how it works? The important files are data/content.css, data/content.js and main.js. The first two are the files injected into penny-arcade.com, and the last one is our add-on entry point.
Let's start with main.js.
Firstly, we require the Add-on SDK modules needed:

var PageMod = require("page-mod").PageMod;
var data = require("self").data;

The PageMod object allows us to create a page-mod; and data object provides an access to the data directory's files.

PageMod({
  // page-mod will added only on the homepage and news page of penny-arcade.com,
  // with or without www as prefix.
  include: /^http:\/\/(www\.)?penny-arcade.com(\/|\/\d{4})?.*/,
  contentScriptFile: data.url("content.js"),
  contentScriptWhen: "ready",
  onAttach: function (worker) {
    worker.port.emit("init", data.url("content.css"));
  }
});

For the main.js, that's all. The addon will load content.js into the page when the DOM is ready for any URL that matches the include property's regular expression. When the page-mod is "attached" to a document, the onAttach callback will emit a custom init event to the content script, passing the URL of content.css.

So, what happens on the other side when the init event is emitted? Let's see content.js:

self.port.on("init", function init(cssURL) {
  // We're not interested in frames
  if (window.frameElement) return;
  addStyleSheet(cssURL);
  var comicsPageURL = document.querySelector(".btnComic").href;
  var http = new XMLHttpRequest();
  http.open("GET", comicsPageURL, true);
  http.onload = addComics;
  http.send();
});

A page-mod is attached to every page that matches the include rule, so frames as well. We are not interested in frames, only in the main page, so with:

if (window.frameElement) return;

We avoid to execute code in that specific case.

Then, we add the stylesheet given using addStyleSheet function, defined in the same file, and we obtain the comics page URL by looking into the DOM.
Because the comic page and the news page are in the same domain, we can use XMLHttpRequest from the content script itself (content scripts follows the Same Origin Policy) instead of having to delegate this task to the Add-on code (that can perform Cross Domain requests).
When we receive the response, the comic page's image url is extracted and displayed in the current page. And that's all!

The behavior related to hide and display the comics image is implemented in css file using media queries:

@media (orientation:portrait) {
  #penny-arcade-addon-comics {
    display: none;
  }
}
@media (orientation:landscape) {
  #penny-arcade-addon-comics {
    display: block;
  }
}

See the results

Navigate into the penny-arcade-comics directory and run it. You should see Fennec Nightly or Aurora ( whichever you specified ) start up on your device. Next, open the Firefox menu, select 'More', then 'Addons'. You should see the list of default addons installed into Firefox, as well as two additions: 'Mobile Addon-SDK utility addon' and 'penny-arcade-comics'.

You can now see how it works at first hand by opening the Penny Arcade site ( http://penny-arcade.com/ ) in Firefox Mobile:

Portrait

Landscape

If you do not have an Android device to test this on, you can still see the effect by installing this addon on Firefox Desktop and re-sizing the window to trigger the media queries we've used in our customer css.

When running the addon on your deivce, you will notice that your shell will be full of javascript warnings; this is because cfx will dump all of Firefox's log messages there. They can be useful, but especially when you work with page-mod it's easy lost your add-on's logging information in this flow. What I usually do instead is open a new shell, and execute a command like that:

adb logcat | grep info:

So, in the shell where cfx is executing I will get all the messages, and in the other one I filtered out only the messages from the add-on.

Conclusion

We're very excited about the possibilities around mobile addons and would love any feedback you might have. Working with the Android SDK currently is a bit awkwards, admittedly. If you do get started creating your own addons for Fennec Nightly, please keep in mind that not all SDK modules work properly.
The modules that currently work are:

page-mod
page-worker
request
self
simple-storage
timers

There are additional modules that mostly work; we are currently working on providing as much support for mobile as possible and will keep you up to date on our progress.

hacks.mozilla.org: FOSDEM 2012: Mozilla Labs Apps and The Future of HTML5 Games

Rob Hawkes — Mon, 06 Feb 2012 10:11:43 +0000

In this post I round-up my first time at FOSDEM and the two talks I gave during my time there; one on open Web apps and the other on creating games with HTML5.

This past weekend I have been in Brussels at FOSDEM, and absolutely massive free event for the open source software community. I hear there were over 5,000 people there this weekend, that’s a lot of people.

Mozilla had a great presence there this year and hosted two full days of talks in the Mozilla DevRoom.

The Developer Engagement team also had a presence this weekend and put on a variety of talks ranging from hacking the Web with Jetpack, to Mozilla’s new perspectives for 2012, to creating open Web documentation.

All in all, FOSDEM is a pretty awesome event absolutely crammed full of developers who care immensely about open software. It is very much a Linux-fest but the talks on Web technologies seemed to go down well. And aside from a few cases of anti-Apple/Microsoft/HTML5 sentiment the event was very successful and well-behaved.

Open Web Apps and the Mozilla Labs Apps project

The first talk that I had the opportunity to give at FOSDEM was on open Web apps and the Mozilla Labs Apps project. It’s a very interesting topic that has been encouraging developers to think beyond the concept of Web apps being something that is just in the browser.

Open Web Games with HTML5 & JavaScript

The second talk that I gave was on open Web game development with HTML5 & JavaScript. During this talk I highlighted a selection of recent events within the HTML5 game industry as well as the key technologies that are involved. I also demoed the Gamepad API working in Firefox with a wireless xBox 360 controller.

Bonjour Mozilla: Serge Gautherie

clarista — Mon, 06 Feb 2012 09:00:00 +0000

Serge Gautherie, alias sgautherie, est un utilisateur et un contributeur de longue date. Son parcours est emblématique de celui d’un contributeur acharné, jamais découragé par les changements opérés par le Panda Roux. Serge a commencé sur Mosaic ! est passé pas Netscape 2, puis 3, puis 4… Avant d’arriver à la suite d’applications Mozilla 0.9.5 (ou quelque chose comme ça) en octobre 2001. 2002 marque le début de ses aventures sur Bugzilla : d’abord il commente un bug, puis en signale, et finalement, en 2004, il se retrouve avec son premier bug assigné ! En fait, ses contributions, dit-il, ont évolué en même temps que ses moyens (et que ses machines). Aujourd’hui, Serge multiplie les patches (pas toujours compliqués, mais souvent très, très utiles), à la grande joie des développeurs de Mozilla qui l’apprécient énormément, et il collabore également à l’assurance qualité de Firefox. Mais actuellement, ce qui lui tient vraiment à cœur est SeaMonkey… Sinon, dans la vie, Serge est ingénieur en informatique, il a travaillé 7 ans avec des technologies JEE et Oracle avant de passer à des jeux internet en PHP/MySQL. Et il possède une petite collection d’anciennes consoles et ordinateurs.

Bonjour Serge !

Serge Gautherie, aka sgautherie, is a user and a long-time contributor. His career is emblematic of a hard working contributor, never discouraged by the changes made by the Red Panda. Serge started on Mosaic! used Netscape 2, then 3, then 4… All that before coming to the Mozilla Application Suite 0.9.5 (or something like that) in October 2001. 2002 marks the beginning of his adventures on Bugzilla: first he posts a comment on a bug, then reports one, and finally, in 2004, he finds himself with his first assigned bug! In fact, his contributions, he said, have evolved along with his resources (and machines). Now, Serge makes several patches (not always complicated, but often very, very useful), to the delight of Mozilla developers who are very grateful, and he also works in quality assurance of Firefox. But now, what is the most important to him is SeaMonkey… Otherwise, Serge is a computer engineer, he worked 7 years with Oracle and JEE technologies before moving on to Internet games in PHP/MySQL. And he owns a small collection of old consoles and computers.

Bonjour Serge!

Tarek Ziadé: Scaling Crypto work in Python

Tarek Ziadé — Mon, 06 Feb 2012 08:03:47 +0000

We’re building a new service at Services called the Token Server – The idea is simple : give us a Browser ID assertion and a service name, and the Token Server will send you back a token that’s good for 30 minutes to use for the specific service.

That indirection makes our live easier to manage user authentication and resource allocation for our services . A few examples:

when a new user wants to use Firefox Sync, we can check which server has the smallest number of allocated users, and tell the user to go there
we can manage a user from a central place
we can manage a user we’ve never heard about before without asking her to register specifically to each service — that’s the whole point of Browser ID

I won’t get into more details because that’s not the intent of this blog post. But if you are curious the full draft spec is here - https://wiki.mozilla.org/Services/Sagrada/TokenServer

What’s this post is really about is how to build this token server.

The server is a single web service that gets a Browser ID assertion and does the following:

verify the assertion
create a token, which is a simple JSON mapping
encrypt and sign the token

The GIL, Gevent, greenlet and the likes

Implementing this using Cornice and a crypto lib is quite simple, but has one major issue : the crypto work is CPU intensive, and even if the libraries we can use have C code under the hood, it seems that the GIL is not released enough to let your threads really use several cores. For example, we benched M2Crypto and it was obvious that a multi-threaded app was locked by the GIL.

But we don’t use threads in our Python servers — we use Gevent workers, which are based on greenlets. But while greenlets help on I/O bound calls, it won’t help on CPU bound work : you’re tied into a single thread in this case and each greenlet that does some CPU work blocks the other ones.

It’s easy to demonstrate — see http://tarek.pastebin.mozilla.org/1476644 If I run it on my Mac Book Air, the pure Python synchronous version is always faster (huh, the gevent version is *much* slower, not sure why..)

So the sanest option is to use separate processes and set up a messaging queue between the web service that needs some crypto work to be done and specialized crypto workers.

We’re back in that case to our beloved 100% I/O bound model we know how to scale using NGinx + GUnicorn + GEvent

For the crypto workers, we want it to be as fast as possible, so we started to look at Crypto++ which seems promising because it uses CPU-specific calls in ASM. There’s the pycryptopp binding that’s available to work with Crypto++ but we happen to need to do some tasks that are not available in that lib yet — like HKDF.

Yeah, at that point it became obvious we’d use pure C++ for that part, and drive it from Python.

Message passing

Back to our Token server — we need to send crypto work to our workers and get back the result. The first option that comes in mind is to use multiprocessing to spawn our C++ workers and to feed them with work.

The model is quite simple, but now that we have one piece in C++, it’s getting harder to use the built-in tools in multiprocessing to communicate with our workers — we need to be lower level and start to work with signals or sockets. And well, I am not sure what would be left of multiprocessing then.

This is doable but a bit of a pain to do correctly (and in a portable way.) Moreover, if we want to have a robust system, we need to have things like a hearbeat, which requires more inter-process message passing. And now I need to code it in Python and C++

Hold on — Let me summarize my requirements:

inter-process communication
something less painful than signals or sockets
very very very fast

I got tempted by Memory Mapped Files, but the drawbacks I’ve read here and there scared me.

ZeroMQ

It turns out zeromq is perfect for this job – there are clients in Python and C++, and defining a protocol to exchange data from the Python web server to the crypto workers is quite simple.

In fact, this can be done as a reusable library that takes care of passing messages to workers and getting back results. It has been done hundreds of times, there are many examples in the zmq website, but I have failed to find any Python packaged library that would let me push some work to workers transparently, via a simple execute() call — if you know one tell me!.

So I am building one since it’s quite short and simple – The project is called PowerHose and is located here : https://github.com/mozilla-services/powerhose.

Here is its descriptions/limitations:

Powerhose is based on a single master and multiple workers protocol
The Master opens a socket and waits for workers to register themselves into it
The worker registers itself to the master, provides the path to its own socket, and wait for some work on it.
Workers are performing the work synchronously and send back the result immediatly.
The master load-balances on available workers, and if all are busy waits a bit before it times out.
The worker pings the master on a regular basis and exits if it’s unable to reach it. It attempts several time to reconnect to give a chance to the master to come back.
Workers are language agnostic and a master could run heterogeneous workers (one in C, one in Python etc..)
Powerhose is not serializing/deserializing the data – it sends plain strings. This is the responsibility of the program that uses it.
Powerhose is not responsible to respawn a master or a worker that dies. I plan to use daemontools for this, and maybe provide a script that runs all workers at once.
Powerhose do not queue works and just rely on zeromq sockets.

The library implements this protocol and gives two tools to use it:

A JobRunner class in Python, you can use to send some work to be done
A Worker class in Python and C++, you can use as a base class to implement workers

Here’s an example of using Powerhose:

The Server – https://github.com/mozilla-services/powerhose/blob/master/examples/square_master.py
The Python worker – https://github.com/mozilla-services/powerhose/blob/master/examples/square_worker.py
The C++ worker (don’t look at the code – https://github.com/mozilla-services/powerhose/blob/master/examples/square_worker.cpp

For the Token server, we’ll have:

A JobRunner in our Cornice application
A C++ worker that uses Crypto++

The first benches look fantastic — probably faster that anything I’d have implemented myself using plain sockets

I’ll try to package Powerhose so other projects at Mozilla can use it. I am wondering if this could be useful to more people, since I failed to find that kind of tool. How do you scale your CPU-bound web apps ?

Filed under: mozilla, python

QMO: WebQA internship opportunity, summer 2012

Stephen Donner — Sun, 05 Feb 2012 21:26:22 +0000

Mozilla QA is looking for passionate and talented interns to take on the challenging position of Software Engineer in Test to help us test and deliver the highest quality Mozilla products and services. In this role you will dive into functionality of Firefox and cutting edge Mozilla web technologies with the goal of developing novel ways to ensure it all works as designed for our 500+ million users.

WebQA’s chief role is to ensure that Mozilla websites are running smoothly and operating flawlessly. To help us achieve that, we are looking for talented interns to be immersed in:

Developing and executing complex manual tests (using multiple browsers, and alongside a plethora of tools) that discover the hard-to-find defects of functionality, security and availability in Mozilla’s web sites such as AMO (https://addons.mozilla.org), SUMO (http://support.mozilla.com) and Mozilla.org: http://mozilla.org
Work with the top contributors of the Selenium test framework project to develop the best automated test solutions to ensure high-quality releases of Mozilla web sites and new cutting-edge Open Web Apps (OWA) project
Contributing to the design and implementation of distributed automated tests and continuous-integration frameworks, such as Hudson/Jenkins. Along the journey, you’ll have the opportunity to involve yourself with and contribute to other great open-source projects, in true Mozilla fashion.

Understanding and extending, Python-based plugins that our team relies on for its testing infrastructure, namely Pytest-MozWebQA (https://github.com/davehunt/pytest-mozwebqa) and Moz-Grid-Config (https://github.com/mozilla/moz-grid-config), among others

Requirements:

Enrollment in a BS/MS in Computer Science or equivalent.
Programming experience in one or more of the following languages; C, C++, Java, Python, JavaScript, and/or Perl.
Expertise in Python and JavaScript a real plus.
Exemplary oral and written communication skills
Have demonstrated a high degree of initiative, self-motivation, and organizational savvy
Clear analytical and problem-solving skills

How to Apply?

Please apply online at: http://bit.ly/xZQmkT

BlueGriffon: 572 new free templates for BlueGriffon!

BlueGriffon — Sun, 05 Feb 2012 10:06:00 +0000

I just added 572 new free HTML+CSS templates to the One-Click Templates add-on for BlueGriffon, for a current total of 1030 available templates !

Andrew Sutherland: about:nosy is about:memory with charts, helps you lay blame more easily

Andrew Sutherland — Sun, 05 Feb 2012 05:25:52 +0000

about:memory and the memory reporter infrastructure that powers it are amazing. They provide an explicit hierarchy that breaks down the memory use in the system to the subsystems and increasingly the causes of allocation. about:memory looks like this (if you stand a few feet back from your monitor and take off your glasses):

If you are going to look at about:memory, it is probably for one of two reasons:

You are Nicholas Nethercote or one of his merry band of MemShrink hackers kicking ass and taking names (of inefficient uses of memory). In this case, about:memory is exactly what you need.
You suspect some tab in Firefox has gone crazy and you want to figure out which one it is and take your vengeance upon it. Vengeance can take the form of thinking mean thoughts, closing the tab, or writing a snarky tweet. about:memory will let you do this, but you have to look at a lot of text and you may already be too late to find the culprit! If only there was an easier way…

Enter about:nosy:

It can show us a list of all the open tabs and their memory usage sans JS for now, as per the above screenshot. If you expand the tab capsules, you get to see the list of all the inner windows/iframes that live in the hierarchy of that page. In most cases the list is either really short and boring or really long and boring. In the case of www.cnn.com I end up with 26 inner windows.

It can also show us memory aggregated by origin. We do show JS for this case because JS is currently only trackable on a per-origin basis. When Bug 650353 gets fixed or the memory reporters get more specific we should be able to apportion JS usage to pages directly.

It also attempts to aggregate extension JS compartments back to their owning extension. We ask the add-on manager for a list of the installed extensions to find their filesystem roots, ask the resource protocol to explain resource mappings, and from there are able to translate such paths. Just keep in mind that traditional overlay-based extensions do not create their own compartments and so are invisible for tracking purposes.

In the screenshot above, you can see that about:nosy keeps the charts exciting by generating a ridiculous amount of garbage all by itself. Much of this is just the about:memory tree-building code that we are reusing. If you refreshed about:memory once a second you would probably see similar garbage creation from the main system JS compartment.

You can install a restartless XPI of the state of the now that will not auto-update. It wants a recent nightly build of Firefox because it makes assumptions about the structure of the memory reporters in order to better serve you.

You can find the source repo on github. It requires the add-on SDK to build. It might seem a little overkill for just graphing memory history, but if you’re looking at the repo you will notice my goal is to use Brian Burg‘s jsprobes work aided by Steve Fink and now de-bitrotted by me (but still a bit crashy) to be able to graph CPU usage, including raw JS, layout/reflow, and paint (eventually, after adding probe points). It’s also possible for those statistics to be gathered via static mechanisms, but the probes are fun and I want to see them work.

Matěj Cepl: Fifth sentence meme

matej — Sun, 05 Feb 2012 00:18:46 +0000

This is very retro, but I like the idea. From Norman Walsh’s blog:

“Grab the nearest book, open it to page 23, find the 5th sentence, and post its text along with these instructions. Point back to where you got the idea so that we can follow the threads.”

So, I did and funny things, the nearest book was Bible (honestly!). So, it is “Připravil jim hostinu, dal napéci nekvašené chleby a pojedli.” For those who don’t understand my beautiful native language, it is Genesis 19:3, which is in NASB translation: “[…] he prepared a feast for them, and baked unleavened bread, and they ate.” Nice text, thinking about it. I am getting hungry.

QMO: Results of Firefox 11.0b1 Testday

ashughes — Sat, 04 Feb 2012 23:51:50 +0000

This past Friday we had a testday for Firefox 11.0b1. I would like to thank everyone who made the event a success.Throughout the day we had 8 testers and 16 moderators working hard to test, confirm bugs, and provide garbage and cycle collector data using the Memchaser add-on. I personally want to thank Aleksej, gaby2300, lcamacho, Swarnava, and everyone else for their hard work.

Stay tuned for details about next week’s Firefox 11.0b2 Mobile testday.

Shane Tomlinson: Experiments for Completing the User Registration Flow in BrowserID

Shane Tomlinson — Sat, 04 Feb 2012 21:25:43 +0000

Over the past several months BrowserID adoption by sites both inside and outside of Mozilla has started to take off. We have received a lot of feedback from site operators, some good, some bad. Far and away the biggest complaint from site operators is that completing the new user flow in BrowserID is causing drop off in potential users converting to verified users. Because of this, our own User Researcher Mary Trombley and UX guru Crystal Beasley have made it their mission to make this experience as smooth as possible.

Mary user tested our current sign up flow with people who had never used BrowserID. The results were eye opening. Users are doing things we suspected may cause problems, but we did not realize the extent of the confusion we were witnessing.

The core problem is that users get lost once they verify their email with BrowserID. No clear indication is given for how to return to the original site being signing up to. Sometimes users close the original site, sometimes they open the verification page in a new window, sometimes they start on mobile and finish on their desktop, sometimes they do everything we expect but don’t realize the original site is still open in another tab. All users see after completing the new user flow is some text that says (paraphrased) “You have finished signing up to BrowserID…. You may now close this window.”

Clearly, we have to do better.

Lloyd Hilaiel came up with some initial ideas outlined in the GitHub Tracking Issue. Skinny (Crystal) took these ideas and ran. She’s got UX talent. The changes she suggested were so obvious it was like “duh, how did we not think of this before?” But then again, it’s easy to say that in retrospect – the process for coming up with a smooth flow is anything but smooth.

Lloyd and Skinny’s initial suggestion was to use some browser trickery to get the user back to the initial site once they have completed the verification step.

If the original site is still open, we can use a window.alert to return focus to its tab. This works in Firefox, Chrome and Safari – neither Opera nor IE play nicely. Mobile browsers universally show the alert message, but fail to return the user to the correct tab.

If the original site is no longer open, we can redirect the verification tab back to the original site. Overall this offers a much better experience, but still leaves a huge hole – if we have to redirect the current tab to the original site, currently we have no way of indicating to that site that the user is now logged in. We think we have a solution to this using DOM events. I did a quick proof of concept on this last night and will post a video once something more concrete is available.

These simple changes boosted our conversion rates quite a bit. Skinny then took the flow and made it even smoother. She thought “why not enter the password inside the dialog?” Brilliant – when the user opens the verification link from their email, they have no additional work to do – all they have to do is worry about logging in.

BrowserID New User Verification Flow Experiments Screencast from Shane Tomlinson on Vimeo.

Both of these flows can be tried with right now. This is experimental work made for user testing and feedback – these flows should not even be considered alpha quality.

Flow 1 – https://feature385.myfavoritebeer.org/ – window.alert if original site is still open or redirect to original site if closed.

Flow 2 – https://feature1000.myfavoritebeer.org/ – Same as flow 1 with initial password entry inside the dialog.

Note, for these experiments we are using “hacksign.in” as our test version of “browserid.org” – you are not being hacked. Both domains are running in separate environments, so you will have to create an account on each.

I will be continue hacking on these flows over the next couple of weeks. Additional user tests will be done. We are going to keep refining until we get it right. Any and all feedback is welcomed and encouraged.

Check it out, see what you think.

Want to get involved?

Check out the code on GitHub.
Message our mailing list at dev-identity@lists.mozilla.org or sign up to receive daily updates.
Come see what we are up to in the Identity group or visit us on IRC in the #identity channel on irc.mozilla.org.

We’d love to hear from you about how we can make this better!

Gregory Jost: Tablets have so much potential, we’re only just scratching...

Sat, 04 Feb 2012 18:11:08 +0000

Tablets have so much potential, we’re only just scratching the surface…

Gregory Jost: Timelapse, London, Ontario.

Sat, 04 Feb 2012 17:33:31 +0000

Timelapse, London, Ontario.

Bogomil Shopov: #Fosdem 2012 – what’s going on.

Bogo — Sat, 04 Feb 2012 16:15:55 +0000

Mozilla’s schedule for FOSDEM is quite busy:

1. There is an online streaming that can be watched from here

2. Follow #mozilla tag to follow what is going on right now at Fosdem – including nice quotes, slides and some hacks like this one:

Hacking the #Fosdem‘s “O” – Hack it and tag it with #fosdem-hack and get nice #Mozilla t-shirt (draw). – See more here

3. if you are here, please stop by our booth and get some buttons and join our effort to make the web better.

Bonjour Mozilla: Fosdem 2012 : Mozilla vous attend

clarista — Sat, 04 Feb 2012 15:19:00 +0000

Le Fosdem a ouvert ses portes, dans la joie et la bonne humeur. Et Mozilla a dressé son stand… Pas à l’emplacement habituel. Alors, armez-vous de courage, mettez votre bonnet et votre écharpe (et des bonnes chaussures pour affronter la neige gelée), et venez nous retrouver au bâtiment K. On vous attend avec plein de jolis goodies :-)

Bonjour le Fosdem !

Fosdem opened, amongst joy and happiness. And Mozilla set up its booth… Not at the usual location. So be courageous, put your hat and your scarf (and good shoes to face the frozen snow), and come find us in the K building. We are waiting for you with lots of nice swag :-)

Bonjour Fosdem!

Tristan Nitot: Mozilla awards grants to six international non-profit organizations

Tristan — Sat, 04 Feb 2012 10:20:00 +0000

Fosdem 2012, under the snow

Earlier today, in FOSDEM in Brussels, a series of grants by Mozilla to non-profit organizations and aimed at Europe have been announced. Here is the announcement:

Mozilla awards grants to six international non-profit organizations

We are pleased to announce that Mozilla awards six international non-profit organizations in Europe and the US with grants for projects that will further strengthen open web, free and open source technologies and user sovereignty on the Web in Europe. Grant recipients are:

April: April is the main French advocacy association devoted to promote and protect Free/Libre Software. It is a major player in spreading the word of free software and open standards to the general public, professionals and institutions in France. It also acts as a watchdog on digital freedoms, warning the public about the dangers of private interests keeping an exclusive stranglehold on information and knowledge.
FOSDEM: The Belgium-based FOSDEM team organizes the free and non-commercial Free and Open source Software Developers' European Meeting (FOSDEM) event to promote the widespread use of Free and Open Source software and provide FOSS projects with a platform to meet, exchange, and collaborate.
Framasoft: Framasoft is one of the most prominent voices of FLOSS (Free, Libre, Open Source Software) in France and other French-speaking countries. The organization’s aim is to educate users about the importance of open software.
Free Software Foundation Europe: Free Software Foundation Europe works across Europe for freedom in the information society by promoting Free Software and Open Standards in politics, business, law, education, and society at large.
Nowoczesna Polska: the Modern Poland Foundation consequently cares for modern education and development of information society in Poland.
Participatory Culture Foundation: The US-based organization is dedicated to creating open and decentralized video tools and services. The grant is earmarked for Universal Subtitles, a project of Participatory Culture Foundation that makes web video accessible through a collaborative platform for captioning and translation of video. Mozilla has collaborated on this open-source project since its creation.

Mozilla has a history of awarding grants to projects that are aligned with its mission. The funds for this round came from Mozilla Europe. Going forward all grant applications, including those for Europe, will go through the Mozilla foundation. Details can be found here: http://www.mozilla.org/grants/ (Once the page has been updated, that is )

Daniel Glazman: 25% rebate on BlueGriffon add-ons today

glazou — Sat, 04 Feb 2012 07:58:00 +0000

During 24 hours only starting right now, get a 25% rebate on BlueGriffon add-ons with coupon code MICHEL on www.bluegriffon.com.

Planet Mozilla

Alexander Surkov: Firefox 11 for AT developers

Bonjour Mozilla: Nikola Matosovic

Brett Gaylor: Mozilla Popcorn aka The Meme Generating Machine

Fork my meme

Popcorn Gallery

Web Made Movies: Roadmap Popcorn Maker 1.0

Roadmapping

Editor UI

Popcorn Gallery

Plugins

Roadmap—want to help?

Web Made Movies: Mozilla Popcorn aka The Meme Generating Machine

Fork my meme

Popcorn Gallery

Ben Moskowitz: Roadmapping Popcorn Maker 1.0

Roadmapping

Editor UI

Popcorn Gallery

Plugins

Roadmap—want to help?

Jess Klein: Day 2 of Open News Sprint- Design for Empathy vs. Pure Utility

Nicholas Nethercote: MemShrink progress, week 34

Add-ons

about:nosy

Miscellaneous

Bug Counts

Meeting Notes from the Mozilla community: SeaMonkey Meeting Minutes: 2012-02-07

SeaMonkey/StatusMeetings/2012-02-07

Contents

Agenda

Action Items

Status of the SeaMonkey Buildbot Master and Tree

Release Train

Extensions Compatibility Tracking

2.x (Last, Current, Next)

2.7

2.Next

Feature List, Planning

Active

Needing help, Unowned, Stalled

Roundtable – Personal Status Updates

Aqualon

asrail

Callek

ewong

IanN

InvisibleSmiley

KaiRo

mcsmurf

Misak

Mnyromyr

MReimer

Neil

Ratty

Ricardo

sgautherie

Stanimir

stefanh

tonymec

Any other business?

Meeting Notes from the Mozilla community: Mozilla Platform Meeting Minutes: 2012-02-07

Platform/2012-02-07

Contents

Notices / Schedule

Firefox Development

Firefox Developer Tools

Performance

GFX

JS

Layout

Video

DOM

WebAPI

Network

Identity

Plugins

Mobile

Accessibility

Tree Management

Crystal Beasley: How People Think Facebook Connect Log‑in and Log‑out Work