Ben Simon: The infrastructure for self-organizing

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.

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

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:

1. 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).
2. 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"

3. 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

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

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

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.”

• Have a look at the DML 2012 Science Fair wiki page
• Check out video from last year’s Mozilla Science Fair at DML
• PDF versions of all designs in this post

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

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

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, “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., you will 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. 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.

So when should I use it, and when not?

You use the “application” role if your widget is one of the following:

• tree view
• slider
• table that is being navigated via the arrow keys, for example a list of e-mail messages where you provide specific information. Other examples are 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. 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 interactable control when you open it.
• toolbar and toolbarbuttons, menus and menu items, and similar
• Any other widget or set of widgets not listed below.

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

Note that this rule does not apply if you put one of these widgets into a wrapping widget (like a dialog or tab panel) that does require the “application” interaction model.

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.

Lawrence Mandel: Firefox Engineering Program Management 4Q 2011 Summary

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.

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

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

Just Browsing: There is war!

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 believes 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 progligious war, although I never was a religious person! Thank god(!) a wise man from a foreign country (Great Britain) knocked my door and stopped me before someone could chop off my head (or I would do so with the other godless sinner), so here a short warning to you all: You can’t win with those people. Don’t go 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 plays different games.. Some of your child’s class mates 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 case of aggression, also the rule “Kill it before it kills us”. Ok, 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 understand it (totally)”. 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 found 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 will 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.”

So please excuse me now – in some coffee a wise man is sitting who urgently needs someone to talk to..

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

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%.

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

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 interviewingTantek Celik, 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:

• http://paulrouget.com/e/openness/
• http://tantek.com/2010/281/b1/what-is-the-open-web
• http://tantek.com/2011/168/b1/practices-good-open-web-standards-development

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

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

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:

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!

Web FWD: Become a WebFWD Affiliate!

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 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:

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

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.

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

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.

More News