http://tenfourfox.blogspot.com/2016/07/tenfourfox-45-is-thing.html

• Use Treeherder as the source for querying jobs

• Allow controlling pulse_actions production behaviour with environment variables

http://feedproxy.google.com/~r/armenzg_mozilla/~3/hRrCl83IXXQ/mozci-and-pulse-actions-contributions.html

Hello, SUMO Nation!

Chances are you have noticed that we had some weird temporal issues, possibly caused by a glitch in the spacetime continuum. I don’t think we can pin the blame on the latest incarnation of Dr Who, but you never know… Let’s see what the past of the future brings then, shall we?

Welcome, new contributors!

• MoraisPuttiVinicius
• KennethGKendall
• Meeta
• thomas_wilson
• the.Derf
• giomanetta
• Naresh Prajapat
• nasvera
• wdot789

If you just joined us, don’t hesitate – come over and say “hi” in the forums!

Most recent SUMO Community meeting

• You can read the notes here and see the video at AirMozilla.
  

The next SUMO Community meeting…

• …is happening on the 27th of July!
• If you want to add a discussion topic to the upcoming meeting agenda:
  • Start a thread in the Community Forums, so that everyone in the community can see what will be discussed and voice their opinion here before Wednesday (this will make it easier to have an efficient meeting).
  • Please do so as soon as you can before the meeting, so that people have time to read, think, and reply (and also add it to the agenda).
  • If you can, please attend the meeting in person (or via IRC), so we can follow up on your discussion topic during the meeting with your feedback.

Community

• PLATFORM REMINDER! The Platform Meetings are BACK! If you missed the previous ones, here is the etherpad, with links to the recordings on AirMo.
  
• Ongoing reminder #1: if you think you can benefit from getting a second-hand device to help you with contributing to SUMO, you know where to find us.
• Ongoing reminder #2: we are looking for more contributors to our blog. Do you write on the web about open source, communities, SUMO, Mozilla… and more? Do let us know!
• Ongoing reminder #3: want to know what’s going on with the Admins? Check this thread in the forum.

Social

• A social sprint for Firefox 48 is taking place soon, stay tuned for more news soon!
• Ongoing reminder: We have a training out there for all those interested in Social Support – talk to Madalina or Costenslayer on #AoA (IRC) for more information.

Support Forum

Firefox

• for Android
  • Version 48 is still on track – release in early August.

• for Desktop
  • Version 48 is still on track – release in early August.

• for iOS
  • 5.0 coming next wek! Get your release hats on!
    
  • Remember, it will be a big update – don’t forget the articles for it are ready to be localized!

Now that we’re safely out of the dangerous vortex of a spacetime continuum loop, I can only wish you a great weekend. Take it easy and keep rocking the helpful web!

https://blog.mozilla.org/sumo/2016/07/21/whats-up-with-sumo-21st-july/

2016 Intern presentation - Sharon Mui

https://air.mozilla.org/metrics-metrics-metr-wait-what-do-you-do/

The official launch of WebExtensions is happening in Firefox 48, but much of what you need is already supported in Firefox and AMO (addons.mozilla.org). The best place to get started with WebExtensions is MDN, where you can find a trove of helpful information. I’d like to highlight a couple of recent additions that you might find useful:

• Comparison with the Add-on SDK chart – SDK developers can see how different SDK APIs and techniques map to their equivalents in the WebExtensions world, so it’s easier to migrate. It’s not a one-to-one match, but it comes close at least for high-level APIs.
• Comparison with XUL/XPCOM extensions chart – Similar to the SDK comparison chart, but a bit trickier to do, given the breadth of the XPCOM platform. We’re using the commonly-used components exposed in Services.jsm for the API mapping table. If you see anything missing on that table, please edit it yourself or let us know.
• How-to guides – There’s a new How to section on the WebExtensions home page that guides you through some common add-on developer cases, like intercepting web requests and adding a button to the toolbar. Let us know if you have other requests for these how-to guides by commenting below, or joining the dev-addons mailing list.

Thank you to Will Bamberg for doing the bulk of this work. Remember that MDN is a community wiki, so anyone can help!

https://blog.mozilla.org/addons/2016/07/21/new-webextensions-guides-and-how-tos-on-mdn/

They say a Mozilla Web QA team member is the most fearless creature in the world. They say their jaws are powerful enough to crush...

https://air.mozilla.org/web-qa-team-meeting-9/

This is a weekly call with some of the Reps to discuss all matters about/affecting Reps and invite Reps to share their work with everyone.

https://air.mozilla.org/reps-weekly-20160721/

Please join us in congratulating Alex Lakatos as Reps of the Month for June 2016!

Alex is a Mozilla Rep based in London, Great Britain, originally from Romania. He is also a Mozilla TechSpeaker, giving talks all around Europe.

In the last 2 months Alex held several technical talks all over Europe (CodeCamp Cluj, OSCAL in Albania, DevTalks in Bucharest and DevSum in Sweden just to name a few) to promote Mozilla’s mission and the Open Web. With his enthusiasm in tech he is a crucial force to promote our mission and educate developers all around Europe about new Web technologies. He covered both the transition we are doing shifting from Firefox OS to a more innovative area with Connected Devices but also changes in Firefox and why you should consider the improvements made on the DevTools side.

Please don’t forget to congratulate him on Discourse!

https://blog.mozilla.org/mozillareps/2016/07/21/rep-of-the-month-june-2016/

I’ve been trying to learn more about how screenshots can help us identify compatibility issues in Firefox. It started with the question:

How does Firefox compare to Chrome in the top 100 websites?

Pretty good it turns out, on the front pages at least, you can view them yourself [Some images are offensive and NSFW]. You can also check out the same list of sites but comparing Firefox to Firefox with tracking protection. I made some scripts to capture the screens in OSX. They make use of the screencapture utility and this other cool little utility called GetWindowID. GetWindowID determines which Window ID is associated to a program on the screen, Firefox or Chrome in this case.

Let’s look at how these utilities work together.

Running the GetWindowID command requires that we specify which program we are looking for and which tab is active as well. I’ve made sure that my version of Firefox starts up with the Mozilla Firefox Start Page. If we execute this command:

./GetWindowID "Firefox" "Mozilla Firefox Start Page";

It returns a numeric value like:
1072

This is great because the screencapture utility needs to know which window ID to look at.
So let’s take that same GetWindowID command from earlier and store the result into a variable called ‘gcwindow’.

gcwindow=$(./GetWindowID "Firefox" "Mozilla Firefox Start Page");

Now gcwindow has the value 1072 from before. Let’s feed that into the screencapture utility:

screencapture -t jpg -T 40 -l $gcwindow -x ~/Desktop/screens/firefoxtest/$site.jpg;

When this runs the program will wait 40 seconds from the "-T 40” parameter then take a screenshot of Window ID 1072, which is our Firefox instance. The JPG file will be stored in a folder on my desktop under screens/firefoxtest. The rest of the script is looping through each website name that we’ve entered, opening a new browser window, opening the website we want to capture, killing the browser process after each screenshot and some sleep commands in between that give the computer time to execute each step.

There are some browser preferences and considerations that you will want to be aware of before running these scripts.

Why do all this in OSX? Cause I like to work on a mac, I guess. OK I don’t have a good reason but if you want to make it work on a Linux docker or something cool that’d be super sweet. The other thing to keep in mind is I’m looking at viewport screenshots right now, full page would be nice, but we’ll get there.

So the side by side comparison of popular sites is pretty useful but looking at things is a lot of work. It would be cool if we could automate some or all of that looking, right? Luckily there are image comparison tools that can help with this. I decided to try out Yahoo’s blink-diff tool which is built using node.js.

First off only PNG’s are supported with this tool, but that’s easy to change using the screencapture command line tool.

So we use 'screencapture -t png’ instead of 'screencapture -t jpg’.

Let’s go through setting this up for a single test. You’ll need to have node.js installed first.
We need to create a new folder, the name isn’t important.

mkdir onetime-diff

Then download this javascript file from Github and put it in that folder. Now let’s initialize our project:

npm init

And just accept all the defaults. Next let’s install the dependancies:

npm install blink-diff
npm install pngjs-image

Great, it’s ready to run now. The index.js file we downloaded looks for two files in the same folder called firefox.png and chrome.png and will generate a file called output.png. If you need a couple files to test with:

firefox.png
chrome.png

Note that if you provide your own PNG files, you may need to adjust the cropping parameters. I’ve configured the script to work best for Firefox and Chrome screenshots captured on a retina display, if you aren’t using a retina display divide those numbers by 2. You can see here y:160 and y:144, this is cropping out the top portion of the screenshot where the browser's “chrome” is.

cropImageA: { x:0, y:160, width:0, height:0 }, // Firefox
cropImageB: { x:0, y:144, width:0, height:0 }, // Chrome

Once you’re ready to run the test, execute:

node index.js

After a minute, it should generate an output.png file that looks like this and the script will return a result to the command prompt:

Passed
Found 1116908 differences.

So this is a good start, we have an image comparison program and an automated screenshot utility. To make it more useful I created another script that combines these together. On a high level it works like this:

First site > Screenshot Firefox > Screenshot Chrome > Compare images in background process > Next Site...

It has the same dependancies as before, but now we run it like this:

./start.sh

After giving this is a few runs and playing with the settings, I started to see some issues.

• Advertisements placed in different positions, sizes, style or even amount
• Regional site redirects
• Different home page, providing a ‘fresh look’ or they are A/B testing
• Site surveys or other pop ups
• Large image sliders
• Random overlay pop up ads
• Rotating background images
• Very slow process when using one computer

We want each site to have a decent amount of time to load, I normally use between 30-40 seconds. But that adds up over 1000 or more sites. I decided to hack something basic together to allow multiple computers in my house to split the load. It helps but it would be much better to have this running on Linux virtual machines or dockers.

So what’s next?

• More sample runs to find a decent set of parameters for the baseline
• Identifying in the top 1000 sites, which ones will continue to fail
• Can we set higher thresholds and still detect when something breaks?
• Can the tool ignore areas that are constantly changing?
• Get the results out in the open for others to look at

If any of this interests you and want to get involved, I’d love to hear from you. Or if you have advice on how to make this better, please reach out as well.

http://bornawesome.com/adam/index.php?id=compatibility-screenshots

We’re improving the way in-page localization works in Pontoon by droping a feature instead of introducing a new one. Translating text on the web page itself using the contentEditable attribute has been turned off.

That means the actual translation (typing) always takes place in the translation editor, which gives you access to all the relevant information you need for the translation.

The sidebar is always visible, allowing you to select strings from the list and then translate them. Additionally, you can still use the Inspector-like tool to select any localizable string on the page, which will then open in the translation editor in the sidebar to be translated.

Translation within the web page has turned out to be suboptimal for various reasons:

• Original string is not always presented unambiguously, e.g. if containing markup,
• Additional string details like comments and file paths are not displayed,
• Suggestions from history, machinery and other locales are not available,
• Only the first plural form can be translated,
• It’s hard to control markup or new lines on various sites if they’re part of the string.

http://horv.at/blog/improving-in-page-localization-in-pontoon/

In Feburary we rolled out Firefox Accounts on addons.mozilla.org (AMO). That first phase created a migration flow from old AMO accounts over to Firefox Accounts. Since then, 84% of developers who have logged in have transitioned over to a Firefox Account.

The next step is to remove the ability to log in using an old AMO account. Once this is complete, the only way to log in to AMO is by using Firefox Accounts.

If you have an old account on AMO and have not gone through the migration flow, you can still access your account if the email you use to log in through Firefox Accounts is the same as the one previously registered on AMO.

We expect that the removal of old logins will be completed in a couple of weeks, unless any unforeseen problems occur.

Frequently asked questions

What happens to the add-ons I develop when I convert to a new Firefox Account?

All the add-ons are accessible to the new Firefox Account.

Why do I want a Firefox Account?

Firefox Accounts is the identity system that is used to synchronize Firefox across multiple devices. Many Firefox products and services will soon begin migrating over, simplifying your sign-in process and making it easier for you to manage all your accounts.

Where do I change my password?

Once you have a Firefox Account, you can go to accounts.firefox.com, sign in, and click on Password.

If you have forgotten your current password:

1. Go to the AMO login page
2. Click on I forgot my password
3. Proceed to reset the password

https://blog.mozilla.org/addons/2016/07/21/completing-firefox-accounts-on-amo/

Hello Mozillians,

Good news! We are having another testday for you

https://quality.mozilla.org/2016/07/firefox-49-0-aurora-testday-july-22nd/

I use TaskWarrior along with TaskWarrior for Android to organize my life. I use FreeCinc to synchronize all of my desktops, VPS, and phone, using a crontask. Most of the time, it works pretty well.

FreeCinc Fail

However, yesterday, all of FreeCinc’s keys expired. There’s a big red warning on the home page instructing users to download new keys.; Since my sync’s operate on a crontask, I didn’t notice this until I discovered tasks I remembered modifying in one place did not appear in another. By that time, I had modifed tasks everywhere – a few things to buy on my phone, some work stuff on the laptop, some more work stuff on the VPS, and some personal stuff on the desktop.

So, downloading new keys is easy. However, TaskWarrior doesn’t magically take four different sets of tasks and combine them into a single coherent set of tasks, just by syncing to a server. No, in fact, since there are no changes to sync, it does nothing. Just leaves the different sets of tasks in place on different machines. So basically everything I modified in 24 hours, across four machines, was now unsynchronized. And I use this to run my life, so it was probably 100 or so changes.

What Was I Doing Again?

Here’s how I fixed this:

I copied pending.data and completed.data from all four hosts onto a single host. These files are in a pretty simple one-task-per-line format, with a uuid and modification timestamp embedded in each line. The rough approach was to take all of the tasks in all of these files, and select most recent instance for each uuid. There’s a little bit of extra complication to handle whether a task is completed or not. I used the following script to do this calculation:

import re

uuid_re = re.compile(r'uuid:"([^"]*)"')
modified_re = re.compile(r'modified:"([0-9]*)"')
def read(filename):
	with open(filename) as f:
		for l in f:
			uuid = uuid_re.search(l).group(1)
			try:
				modified = modified_re.search(l).group(1)
			except AttributeError:
				modified = 0
			yield uuid, int(modified), l

def add_to(uuid, modified, completed, line, coll):
	if uuid in coll:
		ex_modified, ex_completed, _ = coll[uuid]
		if ex_modified >= modified:
			return
		if ex_completed and not completed:
			return
	coll[uuid] = (modified, completed, line)

by_uuid = {}
for c, fn in [
	(True, "rama-completed.data"),
	(True, "hopper-completed.data"),
	(True, "dorp-completed.data"),
	(True, "android-completed.data"),
	(False, "rama-pending.data"),
	(False, "hopper-pending.data"),
	(False, "android-pending.data"),
]:
	for uuid, modified, line in read(fn):
		add_to(uuid, modified, c, line, by_uuid)



with open("completed-result.data", "w") as f:
	for _, completed, line in by_uuid.itervalues():
		if completed:
			f.write(line)

with open("pending-result.data", "w") as f:
	for _, completed, line in by_uuid.itervalues():
		if not completed:
			f.write(line)

As it turns out, I might have simplified this a little by looking at the status field: completed and deleted are in completed.data, and the rest are in pending.data.

Once I was happy with the results (approximately the right number of pending tasks, basically), I copied them into ~/.task on one machine, and ran some task queries to check everything looked good (looking for tasks I recalled adding on various machines). Satisfied with this, I downloaded yet another set of keys from FreeCinc and installed them on that same machine. I deleted ~/.task/backlog.data on that machine (just in case) and ran task sync init which appeared to upload all pending tasks. Great!

Next, I deleted ~/.task/*.data on all of the other machines, installed the new FreeCinc keys, and ran task sync. On these machines, it happily downloaded the pending tasks. And we’re back in business!

I chose not to just copy ~/.task/*.data between systems because I run slightly different versions of TaskWarrior on different systems, so the data format might be different. I might have used task export and task import with some success, but I didn’t think of it in time.

http://code.v.igoro.us/posts/2016/07/taskwarrior-corruption.html

Mozilla Clubs are excited to share our goals for the rest of 2016. We’ve come a long way since the program’s launch in 2015. What lies ahead for us is exciting and challenging. Below is what we will be working on and information about how you can join in the fun.

Curious to learn more about Mozilla Clubs? Check out our website, facebook page, event gallery, and discussion forum.

Mozilla Club leaders came together in June 2016 at Mozilla all-hands. Photo by Randy Macdonald

Our process

In June 2016, eight Mozilla Club leaders came together in London, UK for Mozilla’s bi-annual All Hands gathering. They participated in many conversations, one of which was a 90 minute deep dive session to identify objectives for clubs over the next six months. During the session we brainstormed topics, ideated in pairs and had a group share out. In addition to informing our goals for the rest of 2016, this session gave club leaders the opportunity to learn more about each other’s work and regional challenges.

In July, we shared the results of our deep dive session more broadly during our monthly call for club leaders and internal clubs info session. This allowed us to gather more feedback and ultimately votes on what goals we should focus on for Mozilla Clubs between now and January 2017.

Here is the list of goals that resulted, why they are important to our work how we plan to approach them.

Six Month Goals

Curate and/or create new resources for running clubs offline

• Why: We want to build and curate more web literacy curriculum that can be used without internet access so that club participants can learn offline.
• How: We will make our current offline activities and curriculum easier to locate, curate new resources and build new ones.

Connect the community through a global gathering

• Why: Club participants learn from each other and feel connected to a global community when they have the opportunity to see each other face-to-face.
• How: We will draw from event models across Mozilla like global sprints, state of the Hive and Mozilla Festival to connect club participants (virtually and/or in person) to work on challenges, share experiences and exchange knowledge.

Continue to localize content and resources

• Why: As we translate more curriculum, activities and club guides into languages other than English more people can access and learn from them.
• How: We will work with Mozilla volunteers, staff and partners to build localization into the process of content creation and start with translating current activities and creating new location-specific resources.

Reward and recognize club leaders

• Why: Club leaders need rewards and recognition for their work so that they feel empowered to grow and spread web literacy in their communities.
• How: We will recognize club leaders for their work through a formal rewards process and develop an agreement policy to create more clarity around the responsibilities of being a club leader.

Strengthen clubs as an organizing model for Mozilla campaigns

• Why: Mozilla Club participants should continue to have an active role in Mozilla campaigns like Maker Party, Copyright, Take back the Web, Encryption, etc.
• How: We will leverage club calls, office hours, the discussion forum, etc. to get input from club participants as campaigns take shape and will share campaign related activities that can be incorporated into their offerings.

Connect club participants across Mozilla

• Why: Mozilla program participants have a lot of expertise to share and they should be able to connect with each other easily and frequently.
• How: Create opportunities for community members in Clubs, Hives, Open Science and Advocacy to share work with each other, get feedback, build networks and more.

Assess club activity

• Why: It is important that we maintain an accurate and up-to-date list of active clubs so that we can provide support where it is needed most.
• How: We will identify which clubs are active by holding individual meetings, checking in via email and reviewing the club event reporter.

Join in the fun!

Here are some ways you can contribute to our work over the next six months and beyond.

1. Connect with a Mozilla Club in your area. Don’t see any clubs in your area? Apply to start your own!
2. Help us translate one of our web literacy activities into your preferred language.
3. Use our offline activities, tell us what you think and suggest new ones.
4. Join our facebook group to get updates about upcoming events and campaigns.

http://www.juliavallera.com/blog/mozilla-clubs-end-of-year-goals/

since merging john and i’s css PR, i’ve been digging into min-vid again. lots has changed! dave rewrote min-vid in react.js to make it easier for contributors to plug in.

why react.js? because we won’t have to write a thousand different platform checks anymore. for example, we’d have to trigger one set of behaviors if the platform was youtube.com and another set of behaviors if the platform was vimeo.com. this wasn’t scalable and it wasn’t very contributor-friendly. now, to add support for additional video-streaming platforms, contributors will just have to construct the URL to access the platform’s video files (hopefully via a well-documented API) and add the new URL constructing code to min-vid’s /lib folder in file called get-[platform]-url.js.

so that’s awesome!

right now, i’m working on how to make the video panel draggable within the browser window so you’re not just limited to watching yr vids in the lower left-hand corner:

john came up with a hacky idea for draggability where, on mouseDown, we’ll:

1. create an invisible container the size of the entire browser window
2. as long as mouseDown is true, drag the panel wherever we want within the invisible container
3. onMouseUp, snap the container to be the size of the panel again.

the idea is to make dragging less glitchy by changing our dragging process so we’re no longer sending data back and forth between react, the add-on, and the window.

how to get started? jared broke down the task into smaller pieces for me. here’s the first piece:

the function for setting up the panel size is in the index.js file. we determine how and when to panel.show() and panel.hide() based on the block of code below. the code tells the panel to listen for

1. a message being emitted and
2. for the content of that message, in this case from the controls.js file:

// require the Panel element from the Mozilla SDK
var panel = require('sdk/panel').Panel({
// set the panel content using the /default.html file
  contentURL: './default.html',
// set the panel functionality using the /controls.js file
  contentScriptFile: './controls.js',
// set the panel dimensions and position
  width: 320,
  height: 180,
  position: {
    bottom: 10,
    left: 10
  }
});

then, do different stuff based on what the message said.

// turn the panel port on to listen for a 'message' being emitted
panel.port.on('message', opts => {
// assign title to be whatever 'opts' were emitted
  var title = opts.action;

  if (title === 'send-to-tab') {
    const pageUrl = getPageUrl(opts.domain, opts.id);
    if (pageUrl) require('sdk/tabs').open(pageUrl);
    else console.error('could not parse page url for ', opts); // eslint-disable-line no-console
    panel.hide();
  } else if (title === 'close') {
    panel.hide();
  } else if (title === 'minimize') {
    panel.hide();
    panel.show({
      height: 40,
      position: {
        bottom: 0,
        left: 10
      }
    });
  } else if (title === 'maximize') {
    panel.hide();
    panel.show({
      height: 180,
      position: {
        bottom: 10,
        left: 10
      }
    });
  }
});

i added another little chunk in there which says: if the title is drag, hide the panel and then show it again with these new dimensions. the whole new block of code looks like this:

panel.port.on('message', opts => {
  var title = opts.action;

  if (title === 'send-to-tab') {
    const pageUrl = getPageUrl(opts.domain, opts.id);
    if (pageUrl) require('sdk/tabs').open(pageUrl);
    else console.error('could not parse page url for ', opts); // eslint-disable-line no-console
    panel.hide();
  } else if (title === 'close') {
    panel.hide();
  } else if (title === 'minimize') {
    panel.hide();
    panel.show({
      height: 40,
      position: {
        bottom: 0,
        left: 10
      }
    });
  } else if (title === 'maximize') {
    panel.hide();
    panel.show({
      height: 180,
      position: {
        bottom: 10,
        left: 10
      }
    });
  }
  else if (title === 'drag') {
    panel.hide();
    panel.show({
      height: 360,
      width: 640,
      position: {
        bottom: 0,
        left: 0
      }
    });
  }
});

so we have some new instructions for the panel. but how do we trigger them?  we trigger the instructions by creating the drag function within the PlayerView component and then rendering it. this code says: on whatever new custom event, send a message. the content of the message is an object with the format {detail: obj}—in this case, {action: 'drag'}. then, render the trigger in a

function sendToAddon(obj) {
  window.dispatchEvent(new CustomEvent('message', {detail: obj}));
}

const PlayerView = React.createClass({
  getInitialState: function() {
    return {showVolume: false, hovered: false};
  },
  drag: function() {
    sendToAddon({action: 'drag'});
  },
...
render: function() {
    return (
     

       
     
    );
  }
...

.drag {
    background: red;
}

http://www.jkitppit.com/2016/07/20/draggable-min-vid-part-1/

Once a month, web developers from across the Mozilla Project get together to talk about our side projects and drink, an occurrence we like to call “Beer and Tell”.

There’s a wiki page available with a list of the presenters, as well as links to their presentation materials. There’s also a recording available courtesy of Air Mozilla.

Moby von Briesen: Jam Circle

This week’s only presenter was mobyvb, who shared Jam Circle, a webapp that lets users play music together. Users who connect join a shared room and see each other as circles connected to a central node. Using the keyboard (or, in browsers that support it, any MIDI-capable device), users can play notes that all other users in the channel hear and see as colored lines on each circle’s connection to the center.

The webapp also includes the beginnings of an editor that will allow users to write chord progressions and play them alongside live playback.

A instance of the site is up and running at jam-circle.herokuapp.com. Check it out!

If you’re interested in attending the next Beer and Tell, sign up for the dev-webdev@lists.mozilla.org mailing list. An email is sent out a week beforehand with connection details. You could even add yourself to the wiki and show off your side-project!

See you next month!

https://blog.mozilla.org/webdev/2016/07/20/beer-and-tell-july-2016/

https://danielpocock.com/how-many-mobile-phone-accounts-will-be-hijacked-this-summer

mconley livehacks on real Firefox bugs while thinking aloud.

https://air.mozilla.org/the-joy-of-coding-episode-64/

Bringing fresh ideas to life and ultimately to market is not a well charted course. In July, our guest Tina Seelig will share a new...

https://air.mozilla.org/the-invention-cycle-going-from-inspiration-to-implementation-with-tina-seelig/

This is the sumo weekly call

https://air.mozilla.org/weekly-sumo-community-meeting-july-20-2016/