Doug Belshaw: What a post-Persona landscape means for Open Badges |
Note: I don’t work for Mozilla any more, so (like Adele) these are my thoughts ‘from the outside’…
Open Badges is no longer a Mozilla project. In fact, it hasn’t been for a while — the Badge Alliance was set up a couple of years ago to promote the specification on a both a technical and community basis. As I stated in a recent post, this is a good thing and means that the future is bright for Open Badges.
However, Mozilla is still involved with the Open Badges project: Mark Surman, Executive Director of the Mozilla Foundation, sits on the board of the Badge Alliance. Mozilla also pays for contractors to work on the Open Badges backpack and there were badges earned at the Mozilla Festival a few months ago.
Although it may seem strange for those used to corporates interested purely in profit, Mozilla creates what the open web needs at any given time. Like any organisation, sometimes it gets these wrong, either because the concept was flawed, or because the execution was poor. Other times, I’d argue, Mozilla doesn’t give ideas and concepts enough time to gain traction.
Open Badges, at its very essence, is a technical specification. It allows credentials with metadata hard-coded into them to be issued, exchanged, and displayed. This is done in a secure, standardised manner.
For users to be able to access their ‘backpack’ (i.e. the place they store badges) they needed a secure login system.Back in 2011 at the start of the Open Badges project it made sense to make use of Mozilla’s nascent Persona project. This aimed to provide a way for users to easily sign into sites around the web without using their Facebook/Google logins. These ‘social’ sign-in methods mean that users are tracked around the web — something that Mozilla was obviously against.
By 2014, Persona wasn’t seen to be having the kind of ‘growth trajectory’ that Mozilla wanted. The project was transferred to community ownership and most of the team left Mozilla in 2015. It was announced that Persona would be shutting down as a Mozilla service in November 2016. While Persona will exist as an open source project, it won’t be hosted by Mozilla.
Although I’m not aware of an official announcement from the Badge Alliance, I think it’s worth making three points here.
If you’re a developer, you can still use Persona. It’s open source. It works.
The Open Badges backpack is one place where users can store their badges. There are others, including the Open Badge Passport and Open Badge Academy. MacArthur, who seed-funded the Open Badges ecosystem, have a new platform launching through LRNG.
It is up to the organisations behind these various solutions as to how they allow users to authenticate. They may choose to allow social logins. They may force users to create logins based on their email address. They may decide to use an open source version of Persona. It’s entirely up to them.
The Persona authentication system runs off email addresses. This means that transitioning from Persona to another system is relatively straightforward. It has, however, meant that for the past few years we’ve had a recurrent problem: what do you do with people being issued badges to multiple email addresses?
Tying badges to emails seemed like the easiest and fastest way to get to a critical mass in terms of Open Badge adoption. Now that’s worked, we need to think in a more nuanced way about allowing users to tie multiple identities to a single badge.
Persona was always a slightly awkward fit for Open Badges. Although, for a time, it made sense to use Persona for authentication to the Open Badges backpack, we’re now in a post-Persona landscape. This brings with it certain advantages.
As Nate Otto wrote in his post Open Badges in 2016: A Look Ahead, the project is growing up. It’s time to move beyond what was expedient at the dawn of Open Badges and look to the future. I’m sad to see the decline of Persona, but I’m excited what the future holds!
Header image CC BY-NC-SA Barbara
|
|
This Week In Rust: This Week in Rust 114 |
Hello and welcome to another issue of This Week in Rust! Rust is a systems language pursuing the trifecta: safety, concurrency, and speed. This is a weekly summary of its progress and community. Want something mentioned? Tweet us at @ThisWeekInRust or send us an email! Want to get involved? We love contributions.
This Week in Rust is openly developed on GitHub. If you find any errors in this week's issue, please submit a PR.
This week's edition was edited by: nasa42, brson, and llogiq.
164 pull requests were merged in the last week.
See the triage digest and subteam reports for more details.
str::replace take a pattern.impl for Box from String.Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:
Every week the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now. This week's FCPs are:
[ to the FOLLOW(ty) in macro future-proofing rules.for loop desugaring to use language items.IndexAssign trait that allows overloading "indexed assignment" expressions like a[b] = c.alias attribute to #[link] and -l.some! macro for unwrapping Option more safely.volatile_load and volatile_store intrinsics as ptr::volatile_read and ptr::volatile_write.If you are running a Rust event please add it to the calendar to get it mentioned here. Email Erick Tryzelaar or Brian Anderson for access.
Tweet us at @ThisWeekInRust to get your job offers listed here!
This week's Crate of the Week is toml, a crate for all our configuration needs, simple yet effective.
Thanks to Steven Allen for the suggestion.
Submit your suggestions for next week!
Borrow/lifetime errors are usually Rust compiler bugs. Typically, I will spend 20 minutes detailing the precise conditions of the bug, using language that understates my immense knowledge, while demonstrating sympathetic understanding of the pressures placed on a Rust compiler developer, who is also probably studying for several exams at the moment. The developer reading my bug report may not understand this stuff as well as I do, so I will carefully trace the lifetimes of each variable, where memory is allocated on the stack vs the heap, which struct or function owns a value at any point in time, where borrows begin and where they... oh yeah, actually that variable really doesn't live long enough.
Thanks to Wa Delma for the suggestion.
Submit your quotes for next week!
http://this-week-in-rust.org/blog/2016/01/18/this-week-in-rust-114/
|
|
Nikki Bee: Okay, But What Does Your Work Actually Mean, Nikki? Part 2: The Fetch Standard and Servo |
In my previous post, I started discussing in more detail what my internship entails, by talking about my first contribution to Servo. As a refresher, my first contribution was as part of my application to Outreachy, which I later revisited during my internship after a change I introduced to the HTML Standard it relied on. I’m going to expand on that last point today- specifically, how easy it is to introduce changes in WHATWG’s various standards. I’m also going to talk about how this accessibility to changing web standards affects how I can understand it, how I can help improve it, and my work on Servo.
There are many ways to get involved with WHATWG, but there are two that I’ve become the most familiar with: firstly, by opening a discussion about a perceived issue and asking how it should be resolved; secondly, by taking on an issue approved as needing change and making the desired change. I’ve almost entirely only done the former, and the latter only for some minor typos. Any changes that relate directly to my work, however minor, are significant for me though! Like I discussed in my previous post, I brought attention to an inconsistency that was resolved, giving me a new task of updating my first contribution to Servo to reflect the change in the HTML Standard. I’ve done that several times since, for the Fetch Standard.
My first two weeks of my internship were spent on reading through the majority of the Fetch Standard, primarily the various Fetch functions. I took many notes describing the steps to myself, annotated with questions I had and the answers I got from either other people on the Servo team who had worked with Fetch (including my internship mentor, of course!) or people from WHATWG who were involved in the Fetch Standard. Getting so familiar with Fetch meant a few things: I would notice minor errors (such as an out of date link) that I could submit a simple fix for, or a bigger issue that I couldn’t resolve myself.
I’m going to go into more detail about some of those bigger issues. From my perspective, when I start a discussion about a piece of documentation (such as the Fetch Standard, or reading about a programming library Servo uses), I go into it thinking “Either this documentation is incorrect, or my understanding is incorrect”. Whichever the answer is, it doesn’t mean that the documentation is bad, or that I’m bad at reading comprehension. I understand best by building up a model of something in my head, putting that to practice, and asking a lot of questions along the way. I learn by getting things wrong and figuring out why I was wrong, and sometimes in the process I uncover a point that could be made more clear, or an inconsistency! I have good examples of both of the different outcomes I listed, which I’ll cover over the next two sections.
Early on in my initial review of the Fetch Standard’s several protocols, I found a major step that seemed to have no use. I understood that since I was learning Fetch on a step-by-step basis, I did not have a view of the bigger picture, so I asked around what I was missing that would help me understand this. One of the people I work with on implementing Fetch agreed with me that the step seemed to have no purpose, and so we decided to open an issue asking about removing it from the standard. It turned out that I had actually missed the meaning of it, as we learned. However, instead of leaving it there, I shifted the issue into asking for some explanatory notes on why this step is needed, which was fulfilled. This meant that I would have a reference to go back to should I forget the significance of the step, and that people reading the Fetch Standard in the future would be much less likely to come to the same incorrect conclusion I had.
Shortly after I had first discovered that apparent issue, I found myself struggling to comprehend a sequence of actions in another Fetch protocol. The specification seemed to say that part of an early step was meant to only be done after the final step. I unfortunately don’t remember details of the discussion I had about this- if there was a reason for why it was organized like this, I forget what it was. Regardless, it was agreed that moving those sub-steps to be actually listed after the step they’re supposed to run after would be a good change. This meant that I would need to re-organize my notes to reflect the re-arranged sequence of actions, as well as have an easier time being able to follow this part of the Fetch Standard.
Like I said at the start of this post, I’m going to talk about how changes in the Fetch Standard affects my work on Servo itself. What I’ve covered so far has mostly been how changes affect my understanding of the standard itself. A key aspect in understanding the Fetch protocols is reviewing them for updates that impact me. WHATWG labels every standard they author as a “Living Standard” for good reason. It was one thing for me to learn how easy it is to introduce changes, while knowing exactly what’s going on, but it’s another for me to understand that anybody else can, and often does, make changes to the Fetch Standard!
When an update is made to the Fetch Standard, it’s not so difficult to deal with as one might imagine. The Fetch Standard always notes the last day it was updated at the top of the document, I follow a Twitter account that posts about updates, and all the history can be seen on GitHub which will show me exactly what has been changed as well as some discussion on what the change does. All of these together alert me to the fact that the Fetch Standard has been modified, and I can quickly see what was revised. If it’s relevant to what I’m going to be implementing, I update my notes to match it. Occasionally, I need to change existing code to reflect the new Standard, which is also easily done by comparing my new notes to the Fetch implementation in Servo!
From all of this, it might sound like the Fetch Standard is unfinished, or unreliable/inconsistent. I don’t mean to misrepresent it- the many small improvements help make the Fetch Standard, like all of WHATWG’s standards, better and more reliable. You can think of the status of the Fetch Standard at any point in time as a single, working snapshot. If somebody implemented all of Fetch as it is now, they’d have something that works by itself correctly. A different snapshot of Fetch is just that- different. It will have an improvement or two, but that doesn’t obsolete anybody who implemented it previously. It just means if they revisit the implementation, they’ll have things to update.
Third post over.
http://nikkisquared.github.io/2016/01/17/what-does-your-work-mean-part-2.html
|
|
Gervase Markham: Convenient… and Creepy |
The last Mozilla All-Hands was at one of the hotels in the Walt Disney World Resort in Florida. Every attendee was issued with one of these (although their use was optional):
It’s called a “Magic Band”. You register it online and connect it to your Disney account, and then it can be used for park entry, entry to pre-booked rides so you don’t have to queue (called “FastPass+”), payment, picking up photos, as your room key, and all sorts of other convenient features. Note that it has no UI whatsoever – no lights, no buttons. Not even a battery compartment. (It does contain a battery, but it’s not replaceable.) These are specific design decisions – the aim is for ultra-simple convenience.
One of the talks we had at the All Hands was from one of the Magic Band team. The audience reactions to some of the things he said was really interesting. He gave the example of Cinderella wishing you a Happy Birthday as you walk round the park. “Cinderella just knows”, he said. Of course, in fact, her costume’s tech prompts her when it silently reads your Magic Band from a distance. This got some initial impressed applause, but it was noticeable that after a few moments, it wavered – people were thinking “Cool… er, but creepy?”
The Magic Band also has range sufficient that Disney can track you around the park. This enables some features which are good for both customers and Disney – for example, they can use it for load balancing. If one area of the park seems to be getting overcrowded, have some characters pop up in a neighbouring area to try and draw people away. But it means that they always know where you are and where you’ve been.
My take-away from learning about the Magic Band is that it’s really hard to have a technical solution to this kind of requirement which allows all the Convenient features but not the Creepy features. Disney does offer an RFID-card-based solution for the privacy-conscious which does some of these things, but not all of them. And it’s easier to lose. It seems to me that the only way to distinguish the two types of feature, and get one and not the other, is policy – either the policy of the organization, or external restrictions on them (e.g. from a watchdog body’s code of conduct they sign up to, or from law). And it’s often not in the organization’s interest to limit themselves in this way.
http://feedproxy.google.com/~r/HackingForChrist/~3/DN054t04_dE/
|
|
Christian Heilmann: Don’t tell me what my browser can’t do! |
Chances are, your guess is wrong!
Arrogance towards possible customers never pays out – as shown in “Pretty Woman”There is nothing more frustrating than being capable of something and not getting a chance to do it. The same goes for being blocked out from something although you are capable of consuming it. Or you’re even willing to put some extra effort or even money in and you still don’t get to consume it.
For example, I’d happily pay $50 a month to get access to Netflix’s world-wide library from any country I’m in. But the companies Netflix get their content from won’t go for that. Movies and TV show are budgeted by predicted revenue in different geographical markets with month-long breaks in between the releases. A world-wide network capable of delivering content in real time? Preposterous — let’s shut that down.
On a less “let’s break a 100 year old monopoly” scale of annoyance, I tweeted yesterday something glib and apparently cruel:
“Sorry, but your browser does not support WebGL!” – sorry, you are a shit coder.
And I stand by this. I went to a web site that promised me some cute, pointless animation and technological demo. I was using Firefox Nightly — a WebGL capable browser. I also went there with Microsoft Edge — another WebGL capable browser. Finally, using Chrome, I was able to delight in seeing an animation.
I’m not saying the creators of that thing lack in development capabilities. The demo was slick, beautiful and well coded. They still do lack in two things developers of web products (and I count apps into that) should have: empathy for the end user and an understanding that they are not in control.
Now, I am a pretty capable technical person. When you tell me that I might be lacking WebGL, I know what you mean. I don’t lack WebGL. I was blocked out because the web site did browser sniffing instead of capability testing. But I know what could be the problem.
A normal user of the web has no idea what WebGL is and — if you’re lucky — will try to find it on an app store. If you’re not lucky all you did is confuse a person. A person who went through the effort to click a link, open a browser and wait for your thing to load. A person that feels stupid for using your product as they have no clue what WebGL is and won’t ask. Humans hate feeling stupid and we do anything not to appear it or show it.
This is what I mean by empathy for the end user. Our problems should never become theirs.
A cryptic error message telling the user that they lack some technology helps nobody and is sloppy development at best, sheer arrogance at worst.
The web is, sadly enough, littered with unhelpful error messages and assumptions that it is the user’s fault when they can’t consume the thing we built.
Here’s a reality check — this is what our users should have to do to consume the things we build:
That’s right. Nothing. This is the web. Everybody is invited to consume, contribute and create. This is what made it the success it is. This is what will make it outlive whatever other platform threatens it with shiny impressive interactions. Interactions at that time impossible to achieve with web technologies.
Whenever I mention this, the knee-jerk reaction is the same:
How can you expect us to build delightful experiences close to magic (and whatever other soundbites were in the last Apple keynote) if we keep having to support old browsers and users with terrible setups?
You don’t have to support old browsers and terrible setups. But you are not allowed to block them out. It is a simple matter of giving a usable interface to end users. A button that does nothing when you click it is not a good experience. Test if the functionality is available, then create or show the button. This is as simple as it is.
If you really have to rely on some technology then show people what they are missing out on and tell them how to upgrade. A screenshot or a video of a WebGL animation is still lovely to see. A message telling me I have no WebGL less so.
Even more on the black and white scale, what the discussion boils down to is in essence:
But it is 2016 — surely we can expect people to have JavaScript enabled — it is after all “the assembly language of the web”
Despite the cringe-worthy misquote of the assembly language thing, here is a harsh truth:
You can absolutely expect JavaScript to be available on your end users computers in 2016. At the same time it is painfully naive to expect it to work under all circumstances.
JavaScript is brittle. HTML and CSS both are fault tolerant. If something goes wrong in HTML, browsers either display the content of the element or try to fix minor issues like unclosed elements for you. CSS skips lines of code it can’t understand and merrily goes on its way to show the rest of it. JavaScript breaks on errors and tells you that something went wrong. It will not execute the rest of the script, but throws in the towel and tells you to get your house in order first.
There are many outside influences that will interfere with the execution of your JavaScript. That’s why a non-naive and non-arrogant — a dedicated and seasoned web developer — will never rely on it. Instead, you treat it as an enhancement and in an almost paranoid fashion test for the availability of everything before you access it.
Sorry (not sorry) — this will never go away. This is the nature of JavaScript. And it is a good thing. It means we can access new features of the language as they come along instead of getting stuck in a certain state. It means we have to think about using it every time instead of relying on libraries to do the work for us. It means that we need to keep evolving with the web — a living and constantly changing medium, and not a software platform. That’s just part of it.
This is why the whole discussion about JavaScript enabled or disabled is a massive waste of time. It is not the availability of JavaScript we need to worry about. It is our products breaking in perfectly capable environments because we rely on perfect execution instead of writing defensive code. A tumblr like Sigh, JavaScript is fun, but is pithy finger-pointing.
There is nothing wrong with using JavaScript to build things. Just be aware that the error handling is your responsibility.
Any message telling the user that they have to turn on JavaScript to use a certain product is a proof that you care more about your developer convenience than your users.
It is damn hard these days to turn off JavaScript – you are complaining about a almost non-existent issue and tell the confused user to do something they don’t know how to.
The chance that something in the JavaScript execution of any of your dozens of dependencies went wrong is much higher – and this is your job to fix. This is why advice like using noscript to provide alternative content is terrible. It means you double your workload instead of enhancing what works. Who knows? If you start with something not JavaScript dependent (or running it server side) you might find that you don’t need the complex solution you started with in the first place. Faster, smaller, easier. Sounds good, right?
So, please, stop sniffing my browser, you will fail and tell me lies. Stop pretending that working with a brittle technology is the user’s fault when something goes wrong.
As web developers we work in the service industry. We deliver products to people. And keeping these people happy and non-worried is our job. Nothing more, nothing less.
Without users, your product is nothing. Sure, we are better paid and well educated and we are not flipping burgers. But we have no right whatsoever to be arrogant and not understanding that our mistakes are not the fault of our end users.
Our demeanor when complaining about how stupid our end users and their terrible setups are reminds me of this Mitchell and Webb sketch.
Don’t be that person. Our job is to enable people to consume, participate and create the web. This is magic. This is beautiful. This is incredibly rewarding. The next markets we should care about are ready to be as excited about the web as we were when we first encountered it. Browsers are good these days. Use what they offer after testing for it and enjoy what you can achieve. Don’t tell the user when things go wrong – they can not fix what you messed up.
https://www.christianheilmann.com/2016/01/16/dont-tell-me-what-my-browser-cant-do/
|
|
Mike Hommey: Announcing git-cinnabar 0.3.1 |
This is a brown paper bag release. It turns out I managed to break the upgrade
path only 10 commits before the release.
git cinnabar fsck doesn’t fail to upgrade metadata.remote.$remote.cinnabar-draft config works again.|
|
Daniel Glazman: Ebook pagination and CSS |
Let's suppose you have a rather long document, for instance a book chapter, and you want to render it in your browser `a la iBooks/Kindle. That's rather easy with just a dash of CSS:
body {
height: calc(100vh - 24px);
column-width: 45vw;
overflow: hidden;
margin-left: calc(-50vw * attr(currentpage integer));
}
Yes, yes, I know that no browser implements that attr()extended syntax. So put an inline style on your body for margin-left: calc(-50vw * where
Then add the fixed positioned controls you need to let user change page, plus gesture detection. Add a transition on margin-left to make it nicer. Done. Works perfectly in Firefox, Safari, Chrome and Opera. I don't have a Windows box handy so I can't test on Edge.
http://www.glazman.org/weblog/dotclear/index.php?post/2016/01/16/Ebook-pagination-and-CSS
|
|
Nicolas Mandil: Mozilla cultural revolution: from ‘radical participation’ to ‘radical user-centric’ |
This post has been written about the Mozilla Foundation (MoFo) 2020 strategy.
The ideas developed in this post are in different levels: some are global, some focus on particular points of the proposed draft. But in my point of view, they all carry a transversal meaning: articulation (as piece connected to a structure allowing movement) with others and consistency with our mission.
On the way to radical participation, Mozilla should be radical 1 user-centric. Mozilla should not go against the social understanding of the (tech and whole society) situation because it’s what is massively shared and what polarizes the prism of understanding of the society. We should built solutions for it and transform (develop and change) it on the way. Our responsibility is to build inclusivity (inclusion strengths) everywhere, to gather for multiplying our impact. We must build (progressive) victories instead of battles (of static positions and postures).
If we don’t do it, we go against users self-perceived need: use. We value our differences more than our commonalities and consider ethic more as an absolute objective than a concrete process: we divide, separate, compete. Our solutions get irrelevant, we get rejected and marginalized, we reject compromises that improve the current situation for the ideal, we loose influence and therefore impact on the definition of the present and future. We already done it for the good and the bad in the past (H.264+Daala, pocket integration, Hello login, no Firefox for iOS, Google fishing vs Disconnect, FxOS Notes app which sync is evernote only, …).
To get a consistent and impactful ability to integrate and transform the social understanding, there are four domains where we can take and articulate (connected structure allowing movement) action:
Our front has two sides: propose and protect. But each of them are connected and can have different strategic expressions, if our actions generate improving (progressive) curves:
Social history is a history of social values. The way we understand and tell the problem determine the solution we can create: we need, all the way long, a shared understanding. Tools and technologies are not tied, bound forever to their social value, which depends on people’s social representations that evolve over time.
An analysis of the creation process is another way to the articulation of product with people and technology.
Platforms move closer to strict ‘walled garden’ ecosystems. We need bridges from lab to home that carry different mix of customization and reliability to support the emancipation curve. We need to build pathways thought audiences and thought IT layers (content, software, hardware, distant service). We should find a convergence between customization (dev code patch to users add-ons) and reliability (self made to mass product), between first time experience, support and add-ons thought all our users’ persona by building bridges, pathways. Mozilla should find ways to integrate learning in its products, in-content, as we have code comment on code: on-boarding levels, progression from simple to high level techniques, reproducible/universal next task/skill building.
Here are the developed ideas, with more reference to our allies and detractors’ products.
First of all, I think the strategy move Mozilla is doing is the right one as it embraces more our real life. People are not defined by one characteristic, we are complex: ex. we can be pedestrian, car driver, biker, Public Transport user… we think and do simultaneously. So why Mozilla should restrict its strategy by targeting people on skills, through education, thought better material only (the Mozilla Academy program). Education, even popular education, can’t do everything for the people to build change. We need a plan that balance intellectual and practical (abstraction/action, think/do) integrating progressive paths to massively scale so we get an impact: build change.
Let’s start by some definitions based on my understanding of some Wikipedia articles. Sociology is the study of the evolution of societies: human organizations and social institutions. It is about the impact of the social dimension on humans representations (ways of thinking) and behaviors (ways of acting). It allows to study the conceptions of social relations according to fundamental criteria (structuralism, functionalism, conventionalism, etc.) and the hooks to reality (interactionism, institutionalism, regulationisme, actionism, etc.), to think and shape the modernity. Currently (and this is key for Mozilla’s positioning), the combination of models replace the models’ unity, which aims to assume the multidimensionality. There are three major sociological paradigms, including one emerging:
Consequently, Mozilla should build its strategy on historical (evolution) and sociological (human organizations, social institutions and social behaviors) analysis based on social networks (links as social interactions), in the perspective of producing commons. That is to say as an engine of transition from a model of value on its last leg (rarity capitalism) to the emerging one (new articulation of the individual and the collective: commons).
It is important and strategic to propose a sociological articulation supporting our mission and its purpose (commons) since the sociological concept (the paradigm) reveals an ideological characteristic: because it participates in societal movements made in the Society, it serves an ideal. The societal domain, what’s making society, a political object, should be a stake for Mozilla.
We should articulate ‘our real life’ with the nowadays tech challenge: how to get back control over our data at the time of IoT, cloud, big data, convergence (multi-devices/form factor)? From a user point of view, we have devices and want them convenient, easy and nice. The big moves in the tech industry (IoT, cloud, big data, convergence) free us for somethings and lock us for others. The lock key is that our devices don’t compute anymore our data that are in silos. From a developer point of view, the innovation is going very fast and it’s hard to have a complete open source toolbox that we can share, mostly because we don’t lead: Open has turn to be more open-releasing.
We should articulate our new strategy with the tech industry moves: for example, as a user, how can I get (email) encryption on all my devices? Should I follow (fragmented) different kind of howtos/tools/apps to achieve that? How do I know these are consistent together? How can I be sure it won’t brake my continuous workflow? (app silo? social silo? level of trust and reliability?)
Mozilla have the skills to answer this as we already faced and solved some of these issues on particular points: like how to ease the installation of Firefox for Android for Firefox desktop users, open and discoverable choice of search engines, synchronization across devices, …
Mozilla’s challenge is to not be marginalized by the change of practices. Having an impact is embracing the new practice and give it an alternative. Mozilla already made that move by saying « Firefox will go where users are« , by trying to balance the advertisement practice between adds companies and users, by integrating H.264 and developing Daala. But Mozilla never stated that clearly as a strategy.
If we think about the Facebook’s strategy, they first built a network of people whiling to share (no matter what they share) and then use this transversal backbone to power vertical business segments (search, donation, local market selling, …). Google with its search engine and its open source policy have a similar (in a way) strategy. The difference here is that the backbone is people’s data and control over digital formats. In both cases, the level of use (of the social network, search engine, mobile OS, …) is the key (with fast innovation) to have an impact. And that’s a major obstacle to build successful alternatives.
The proposed Mozilla’s strategy is built in the opposite way, and that’s questioning. We try to build people network depending on some shared matters. Then, is our strategy able to scale enough to compete against GAFAM, or are we trying to build a third way ?
For the products, the Mozilla’s strategy is still (and has always been) inclusive: everybody can use the product and then benefit of its open web values. A good product that answer people needs, plus giving people back/new power (allow new use) build a big community. For the network, should we build our global force of people based on concentric circles (of shared matters) or based on a (Mozilla own) transversal backbone (matter agnostic)? It seems to me the actual presentation of the strategy do not answer clearly enough this big question: which inclusivity (inclusion strengths) mechanism in the strategy?
And that call back to our product strategy: build a community that shares values, that is used to spread outcomes (product) OR build a community that shares a product, that is used to spread values. This is not a question on what matters more (product VS values) but on the strategy to get to a point, an objective (many web citizens). Shouldn’t we use our product to built a people network backbone ? Back to GAFAM: what can we learn from the Google try with Google+?
If our core is not enough transversal (the backbone), more new web/tech market there will be, more we will be marginalized, because focused on our circles center not taking in account that the war front (the context) have changed. Mozilla have to be resilient: mutability of the means, stability in the objectives.
The document is the MoFo strategy, and so it doesn’t say anything about ‘build Firefox’ (aka the product strategy) and so don’t articulate our main product (Firefox) with our main people network building effort and values sharing engine. We should do it: at a strategic scale and a particular scale (articulating the agenda-setting with main product features).
It seems that our GAFAM challengers get big and have impact by not educating (that much) people, and that’s what makes them not involved in the web citizenship. Or only when they are pushed by their customers. At the opposite, making people aware about web citizenship at first, makes it hard to have that much people involved and so to have impact. However, there is an other prism that drive people: the brand perceived values. Google is seen as a tech pioneer innovator and doing the good because of its open policy, free model, fast innovation… Facebook is seen as really cool firm trying to help people by connecting them…
Is the increase of marketing of Mozilla doing good enough to gains back users ? Is this resilient compared to the next-tech-thing coming ?
Most of the time when I meet Goggle Chrome users and ask then why they use it and don’t switch to Firefox, they answer about use allowed (sync thought devices, apps everywhere that run only on GC, …). Sometimes, they argue that they make effort on other areas, and that they want to keep they digital life simple. They experience is not centered in a product/brand, but more on the person: on that Google Chrome with its Person (with one click ‘auto-login’ to all Google services) is far superior than Firefox.
A user-agent is an intermediary acting on behalf of a supplier. As a representative, it is the contact point with customers; It’s role is to manage, to administer the affairs; it is entrusted with a mission by one or more persons; it both acts and produce an effect.
So, the user-agent can be describe with three criteria. It is: an intermediate (user/technology) ; a tool (used to manage and administrate depending on the user’s skills) ; a representative (mission bearer, values vector, for a group of people). It exceeds partly the contradiction between being active and passive.
A user-agent articulate personal-identity with technology-identity and give informations about available skills over these domains. It’s much more universal than a product that is about featuring a user-agent. If we target resilience, user-agent should be the target.
The way we look at the past and current facts shape our understanding and determine if we open new ways to solve the issues identified. That’s the way to understand the challenges that come on the way and to agree on an adaptation of the strategy instead of splitting things. The way we understand and tell the problem determine the solution we can create: we need, all the way long, a shared understanding.
Tools and technologies are not necessarily tied to their social value, which depends on social representations. The social value can be built upstream and evolve downstream. It also depends on the perspective in which we look at it, on the understanding of the action and therefore on past or current history. Example: the social value of a weapon can be a potential danger or defense, creative (liberating) or destructive. The nuclear bomb is a weapon of mass destruction (negative), whose social value was (ingeniously built as) freedom (positive).
To engage the public, before to « Focus on creative campaigns that use media + software to engage the public. » we need to step back, in our speeding world, for understanding together the big picture and the big movement.
Mozilla want to fuel a movement and propose a strong and consistent strategy. However, I think this plan miss a key point, a root point: build a common (hi)story. This should be an objective, not just an action.
Also, that’s maybe a missing root for the State of the web report: how do we understand what we want to evaluate? But it’s not only a missing root for an (annual?) report (a ‘Reporters without borders’ Press-Freedom like?), it’s a missing root for a new grow of our products’ market share.
For example, I do think that most users don’t know and understand that Mozilla is a foundation, Firefox build by a community as a product to keep the web healthy: they don’t imagine any meaning about technology, because they see it as a neutral tool at its root, so as a tool that should just fit they producing needs.
Firefox, its technologies and its features are not bound for ever. It is the narrative, and therefore their inclusion in the social history that we make, which converges Firefox with the values that it stand for. Stoping or changing the deep narrative means cutting the source of common understanding and making stronger other consistencies captured by other objects, turning as centrifugal forces for Firefox.
Marketing is a way to change what we socially say about things: that’s why Google Chrome marketing campaign (and consistent features maturity) has been the decreasing starting point of Firefox. Our message has been scrambled.
How to emancipate people in the digital world ?
Being open is not a thing we can achieve, it’s a constant process. « Mozilla needs to engage on both fronts, tackling the big problems but also fuelling the next wave of open. » Yes, but Mozilla should say too how the next wave of open can stay under people’s control and rally new people. Not only open code, but open participation, open governance, open organization. Being open is not a releasing policy about objects, it’s a mutation to participation process: a metamorphosis. It’s not reached by expanding, but by shifting. It’s not only about an amount, but about values: it’s qualitative.
Maybe open is not enough, because it doesn’t say enough about who control and how, about the governance, and says too much about availability (passive) and not enough about inclusivity (active ; inclusion strengths). It doesn’t say how the power is organized and articulated to the people (ex. think about how closed is the open Android). We may need to change the wording: indie web, the web that fuel autonomy, is a try, but it doesn’t say enough about inclusivity compared to openness & opportunity. Emancipation is the concept. It’s strategic because it says what is aligned to what, especially how to articulate values and uses. It’s important because it tells what are the sufficient conditions of realization to ‘open/indie’. That’s key to get ‘open/indie at small and large scales, from Internet people to Internet institutions, thought all ‘open/indie’ detractors in the always-current situation: a resilient ecosystem.
My intuition is that the leadership network and advocacy engine promoting open will be efficient if we clarify ‘open’ while keeping it universal. We can do it by looking back at the raw material that we have worked for years, our DNA in action. Because after all, we are experts about it and wish others to become experts too. It does not mean to essentialize it (opposing its nature and its culture), but to define its conditions of continuous achievement in our social context.
Clarifying the idea of ‘open’ is strategic to our action because it outlines the constitution of ‘open’, its high ‘rules’, like with laws in political regimes. It clarifies for all, if you are part of it or not, and it tells you what to change to get in. It can reinforce the brand by differentiating from the big players that are the GAFAM: it’s a way to drive, not to be driven by others lowering the meaning to catch the social impact. We should say that ‘open’ at Mozilla means more than ‘open’ at GAFAM. I wish Mozilla to speak about its openness, not as an ‘equal in opportunity’ but as an ‘equal in participation’, because it fits openness not only for a moment (on boarding) or for a person, but during the whole process of people’s interaction.
Rust and Servo or Firefox OS (since the Mozilla’s shift to radical participation) seem to be very good examples of projects with participation & impact centric rules, tools, process (RFC, new team and owners, …). Think about how Rust and Dart emerged and are evolving. Think about how stronger has been the locked-open Android with partnership than the open-locked FxOS. We should tell those stories, not as recipes that can be reproduced, but as process based on a Constitution (inclusive rules) that make a political regime (open) and define a mode of government (participation). That’s key to social understanding and therefore to transpose and advocate for it.
As projects compared to ‘original Mozilla’, Rust, Servo and FxOS could say a lot about how different they implemented learning/interaction/participation at the roots of the project. How the process, the tools, the architecture, the governance and the opportunities/constraints have changed for Mozilla and participants. This could definitely help to setup our curriculum resources, database and workshop at a personal (e.g., “How to teach / facilitate / organize / lead in the open like Mozilla.”) and orgs levels, with personal and orgs policies.
Clarifying the constitution of ‘open’ calls to clarify other related wordings.
I’m satisfied to read back (social) ‘movement’ instead of ‘community’, because it means that our goal can’t be achieve forever (is static), but we should protect it by acting. And it seems more inclusive, less ‘folds on itself’ and less ‘build the alternative beside’ than ‘community’: the alternative can be everywhere the actual system is. It can make a system. It can get global, convergent, continuous, … all at the same time. Because it’s roots are decentralized _and_ consistent, collaborating, …
About participation, we should think too (again) about engagement VS contribute VS participate: how much am I engaged ? Free about defining and receiving cost/gains? What is the impact of my actions ? … These different words carry different ideas about how we connect the ‘open’: spread is not enough because it diffuses, _be_ everywhere is more permanent. Applied to Mozilla’s own actions, funding open projects and leaders, is maybe not enough and there should be others areas where we can connect inside products, technology, people and organizations that build emancipation. So that say something about getting control (who, how, …).
IA is first developed to help us by improving our interactions. However, this seems to start to shift into taking decisions instead of us. This is problematic because these are indirect and direct ways for us to loose control, to be locked. And that can be as far as computers smarter than humans. The problem is that technical progress is made without any consideration of the societal progress it should made.
That’s an other point, why open is not enough: automation should be build-in with superior humanization. Mozilla should activate and unlock societal progress to build fair technical progress.
The digital (& virtual) world is gaining control over the physical world in many domains of our society (economy to finance, mail to email, automatic car, voting machine, …). It’s getting more and more integrated to our lives without getting back our (imperfect) democracy integrated into them. Public benefit and public good are turning ‘self benefit’ and ‘own sake’ because citizens don’t have control over private companies. We should build a digital democracy if we don’t want to loose at all the democratic governing of society. We must overcome the poses and postures battles about private and public. We need to build.
At some level, I’m not the only one to ask this question:
How do CRM requirements for Leadership and Advocacy overlap / differ? What’s our email management / communications platform for Leadership?
Connect leaders to lead what ? How ? To whose benefit ? Do we want to connect leaders or initiatives (people or orgs) ? Will the leaders be emerging ones (building new networks) or established ones (use they influence to rally more people)? Are Leaders leaders of something part of Mozilla (like can be Reps) or outside of Mozilla (leaders of project, companies, newspaper: tech leaders, news leaders, …) ? This is especially important depending on what is the desire for the leaders to become in the future. The MoFo’s document should be more precise about this and go forward than « Mozilla must attract, develop, and support a global network of diverse leaders who use their expertise to collaboratively advance points-of-view, policies and practices that maintain the overall health of the Internet. »
We should do it because the confusion about the leadership impact the advocacy engine: « The shared themes also provide explicit opportunities for our Leadership and Advocacy efforts to work together. » Regarding Mozilla, is the leaders role to be advocacy leaders ? It seems as they share themes and key initiatives (even if not worded the same sometimes). Or in other words, who Drives the Advocacy engine?
Here are my iterations on the definition of ‘Leaders’:
With these definitions, then Leaders are maybe more a Lab, R&D place, incubation tool (if we think about start-up incubators, then it shows a tool-set that we will need to inspire for the future). But if we want to keep the emphasis on people, we could name them ‘creators’ (compositors or managers ; not commoners, because leaders and advocates are commoners ; yes, traditionally creators are craftspersons and intellectual designers). This make sens with the examples given in the MoFo 2020 strategy 0.8 document, where all persona are involved in a building-something-new process.
However, it’s interesting to understand why we choose at first ‘Leaders’. Leaders build new solutions (products) and Advocates new voices (rallying), they are both about personal development and empower commons. Leadership=learn+create and advocacy=teach+spread commons. Leaders are projects/orgs leaders, the ones that traduce DNA (values) in products (concrete ability and availability). Advocates are values advocates, the ones that traduce DNA (values) in actions (behavior). As they are both targeting commons, they both produce the same social organization (collaboration instead of competition). They are both involved to create (different) representation (institutions) and organization (foundation/firms) but with a different DNA (values) processing: from public good to personal interest or the opposite. If Mozilla cares about public good resilience, the articulation of they domains of values is critical. So their articulation’s expression and the revision process must be said and clear: from hierarchy vs contract vs different autonomy levels (internal incubation and external advocacy), vs … to criteria to start a revision.
Another argument for the switch from Leader to Creator is that the Leader word it too much tight to a single-person-made innovation. Creator make more clear that the innovation is possible not because of one genius, but because of a team, a group, a collective: personS (where there could also be genius). The value is made by the collaboration of people (especially in an open project, especially in a network).
That’s important because that could impact how well we do the convening part: not self-promoting, not-advertising, but sharing skills and knowledge for people and catalysing projects.
The same for the wording ‘talent’: alone, a talent can do nothing that has an impact. At least, we need two talents, a team (plus some assistants at some point).
Again, this seems to be an open question:
Define and articulate “leadership.” Hone our story, ethos and definition for what we mean by “leadership development” (including cultural / localization aspects).
In my culture, Leader carry positive (take action) and negative (dominate) meanings. That’s another reason why I prefer another naming.
I understand too that it carries a lot of legitimacy (ex. market leader) in our societies and it avoids the stay-experimental or non-massive (unique) thoughts. And we need legitimacy to get impact.
But the way Mozilla has an impact thought all cultures, its legitimacy, is by creating or expanding a common. To do this, depending on the maturity, Mozilla could follow the market proposing an alternative with superior usability OR opening a new market by adding a vertical segment.
If Leadership is « a year-round MozFest + Lab« , so it’s a social network + an incubation place. Then, we already have a social network for people involved with Mozilla: Which kind of link should have the leadership network with mozillians.org ? What can we learn from this project and other specialized social network projects (linkedin, viadeo, …) to build the leadership network ?
Mozilla is doing a great effort to build its advocacy engine on collaboration (« Develop new partnerships and build on current partnerships« , « begin collaboration« , « build alliances with similar orgs« ) but at the same time affirms that Mozilla should be « Part of a broader movement, be the boldest, loudest and most effective advocates » that could be seen as too centralized, too exclusive.
While this can be consistent (or contradictory), the consistency has to be explained looking at orgs and people, global and local, abstract and real, with a complementarity/competitive grid.
First, the articulation with other orgs has to be explained. What about others orgs doing things global (EFF, FSF, …) and local (Quadrature du net, CCC, …) ? What about the value they give and that Mozilla doesn’t have (juridic expertise for example) ? What about other advocate engines (change.org, Avaaz…) ? That should not be at an administrative level only like « Develop an affiliate policy. Defining what MoFo does / does not offer to effectively govern relationships w. affiliated partners and networks (e.g., for issues like branding, fundraising, incentives, participation guidelines, in-kind resources.) »
Second, this is key for users to understand and articulate the global level of the brand engagement and their local preoccupations and engagement. How the engine will be used for local (non-US) battles ? In the past Mozilla totally involved against PIPA, SOPA by taking action, and hesitate a lot to take position and just published a blog post (and too late to gain traction and get impact) against French spying law for example.
Third, the articulation ‘action(own agenda)/reaction’ should be clarified in the objectives and functioning of the advocacy engine. Especially because other orgs, allies or detractors, try to to setup the social agenda. It’s important because it can change the social perception of our narrative (alternative promotion/issue fighting) and therefore people’s contributions.
People think the technology is socially neutral. People are satisfied of narrow hills of choice (not the meaning, the aim, but only the ability to show your favorite avatar). People don’t want to feel guilty or oppressed, they don’t want new constraints, they are looking for solution only: they want to use, not to do more, they want they things to be done. Part of the problem is about understanding (literacy, education), part of it is about the personal/common duality, part of it is about being hopeless about having an impact, part of it is about expressing change as a positive goal and a new possible way (alternative), not a fight against an issue. About the advocacy engine, I think our preoccupation should be people-centric and the aim to give them a short, medium and long term narrative to get action without being individuals-centric.
How to build a social movement ? How it has been built in the past ? Is it the same today ? Can it be transposed to the digital domain from others social domains ? How strong are the cultural differences between nations? These are the main questions we should answer, and our pivot era gives us many examples in diverse domains (climate change advocates, Syriza & Podemos, NSA & surveillance services in Europe, empowered syndicates in Venezuela, Valve corp. internal organization…) to set a search terrain. However, I will go strait to my intuitive understanding below.
I’m kind of worried that it’s imagined to build the advocacy engine themes by a top-down method. I think a successful advocacy is always built bottom-up, as its function is to give back the voice to the people, to get them involved, not to make them fulfill our predefined aims. The top-down method is too organization centric: it can’t massively drive people that are not already committed to the org. It’s usually named advertisement or propaganda. If we want to have impact, we should listen to people needs, not tell them to listen to ours. People want (first) to be empowered, not to empower an org. So let’s organize the infrastructure, set the agenda and draw the horizon (strategic understanding) participative: make people fill them with content of their experience. It seems to me it is the only way, the only successful method, if we want to build a movement, and not just a shifting moment (that could be built by the top, with a good press campaign locally relayed for example ; that’s what happen in old style politics: the aim is short term, to cleave).
Isn’t the advocacy engine a new Drumbeat ? We shifted from Drumbeat to Webmaker+web literacy to Mozilla Academy and now to Leadership plus advocacy: it could be good to tell that story now that we are shifting again and learn from it.
Mozilla should support, behave as a platform, not define, not focus. Letting the people set the agenda makes them more involved and is a good way to build a network of shared aims with other orgs, that is not invasive or alienating, but a support relationship in a win-win move. The strength comes from the all agendas sewed. So at an org level, let’s on-board allies organizations as soon as plan building-time (now), to build it together. Yes it’s slower, but much more massive, inclusive and persistent.
First, about the agenda-setting KPI for 2016, should these KPI be an evaluation of the inclusion and rank in others strategic agendas, governance systems and productions (outcome/products) ? Others org could be from different domains: political, social, economy orgs.
Then, as a wide size audience KPI, Mozilla wants « celebration of our campaigns with ‘headline KPIs’ including number of actions, and number of advocates.« . While doing this could be the right thing to do for some cultures, it could be the worst for others. I think that these KPI don’t carry a meaning for people and are too org centric. In a way, they are to generic: it’s just an amount. Accumulation is not our goal: we want impact that is the grow of articulated actions made by diverse people toward the same aim. We need our massive KPI to be more qualitative, or at least find a way to present them in a more qualitative way: interactive map ? a global to local prism that engages people for the next step ?
Selecting best practices are an appealing method when we want to have a fast and strong impact in a wide area. However, when we unify we should avoid to homogenize. The gain in area by scaling-up is always at the cost of loosing local impact because it is not corresponding to local specificities, hence to local expectations. Federating instead of scaling-up is a way to solve this challenge. So we should be careful to not use best practice as absolute solutions, but as solutions in a context if we want to transpose them massively.
It’s good to hear that we will build a advocacy platform. As we ‘had’ bugzilla+svn then mercurial (hg)+… and are going to the integrated, pluggable and content-centric (but non-free; admin tools are closed source) github (targeting more coder than users, but with a lower entry price for users still), we need to be able to have the same kind of tool for advocates and leaders. Something inspired maybe at some levels by the remixing tools we built in Webmakers for web users.
We need pathways from lab to home that carry different mix of customization and reliability to support the emancipation curve.
Users want things to work, because they want to use it. Geeks want to be able to modify a lot and accept to put their hands in the engine to build growing reliability. Advanced users want to customize their experience and keep control and understanding on working status. They want to be able to fix the reliability at a medium/low technical cost. They are OK to gain more control at these prices. Users want to use things to do what they need and want to trust a reliability maintained for them. They are OK to gain control at a no technical cost. Depending on the matter we all have different skill levels, so we are all geeks, advanced users and users depending on our position or on the moment. And depending on our aspirations, we all want to be able to move from one category to an other. That’s what we need to build: we don’t just need to « better articulate the value to our audiences« , we need to build pathways thought audiences and thought IT layers (content, software, hardware, distant service). We should find a convergence between customization and reliability, between first time experience, support and add-ons thought all our users’ persona by building bridges, pathways. So, « better articulate the value to our audiences » should not be restrained in our minds to the Mozilla Leadership Network.
Part of this is being done in other projects outside of Mozilla in the commons movement. There are many, but let’s take just one example, the Fairphone project: modularity, howtos, … all this help to break the product-to-use walls and drive appropriation/emancipation. Products are less product and brand centric and more people/user centric.
Part of this has been done inside Mozilla, like integrating learning in our products, in-content, as we have code comment on code. I think the Spark project on Firefox OS is on a promising path, even if maybe immature: it maybe has not been released mainstream because it misses bridges/pathways (on-boarding levels, progression from simple to high level techniques, and no or not enough reproducible/universal next task/skill building).
So some solutions start to emerge, the direction is here, but has never been conceived and implemented that globally, as there isn’t integrated pathways with choice and opportunity and a strategy embracing all products and technologies (platform, tools, …).
The open community should definitely improve the collaboration tools and infrastructure to ease participation.
Discourse ‘merged’ discussion channels: email+forum(+instant, messaging, … and others peer-to-peer discussion?). Stack exchange merged the questioning/solving process and added a vote mechanism to rank answers: it eased the collaboration on editing the statement and the results while staying synchronous with the discussion and keeping the discussion history. We need such kind of possibilities with discourse: capitalize on the discussion and preview the results to build a plan.
This exist in document oriented software (that added collaboration editing tools), but not that much in collaboration software (that don’t produce documents). For example, while discussing the future plan for Fx/FxOS be supported to keep track on a doc about the proposals plans + criteria & dependencies. In action, it is from this plus all the discussion taking place to that.
This is maybe something like integrating Discourse+Wiki, maybe with the need to have competing and ranked (both for content and underlaying meaning of content=strategy?) plan/page proposals. From evolving the wiki discussion page to featuring document production into peer-to-peer discussion.
There is maybe one thing that is in the shadow in this plan: what do we do when/if we (partially) fail ?
I think at least we should say that we document (keep research going on) to be able to outline and spread the outcomes of what we tried to fight against. So we still try to built consciousness to be ready for the next round.
If you see some contradiction in my thoughts, let’s say it’s my state of thinking right now: please voice them so we can go forward.
The same for thoughts that are voiced definitive (like users are): take it as a first attempt with my bias: let’s state these bias to go forward.
|
|
Chris Cooper: RelEng & RelOps Weekly Highlights - January 15, 2016 |
One of releng’s big goals for Q1 is to deliver a beta via build promotion. It was great to have some tangible progress there this week with bouncer submission.
Lots of other stuff in-flight, more details below!
Modernize infrastructure:
Dustin worked with Armen and Joel Maher to run Firefox tests in TaskCluster on an older EC2 instance type where the tests seem to fail less often, perhaps because they are single-CPU or slower.
Improve CI pipeline:
We turned off automation for b2g 2.2 builds this week, which allowed us to remove some code, reduce some complexity, and regain some small amount of capacity. Thanks to Vlad and Alin on buildduty for helping to land those patches. (https://bugzil.la/1236835 and https://bugzil.la/1237985)
In a similar vein, Callek landed code to disable all b2g desktop builds and tests on all trees. Another win for increased capacity and reduced complexity! (https://bugzil.la/1236835)
Release:
Kim finished integrating bouncer submission with our release promotion project. That’s one more blocker out of the way! (https://bugzil.la/1215204)
Ben landed several enhancements to our update server: adding aliases to update rules (https://bugzil.la/1067402), and allowing fallbacks for rules with whitelists (https://bugzil.la/1235073).
Operational:
There was some excitement last Sunday when all the trees were closed due to timeouts connectivity issues between our SCL3 datacentre and AWS. (https://bugzil.la/238369)
Build config:
Mike released v0.7.4 of tup, and is working on generating the tup backend from moz.build. We hope to offer tup as an alternative build backend sometime soon.
See you all next week!
|
|
Air Mozilla: Webdev Beer and Tell: January 2016 |
Once a month web developers across the Mozilla community get together (in person and virtually) to share what cool stuff we've been working on in...
|
|
Support.Mozilla.Org: What’s up with SUMO – 15th January |
Hello, SUMO Nation!
The second post of the year is here. Have you had a good time in 2016 so far? Let us know in the comments!
Now, let’s get going with the updates and activity summaries. It will be brief today, I promise.
We salute you!
Not that many updates this week, since we’re coming out of our winter slumber (even though winter will be here for a while, still) and plotting an awesome 2016 with you and for you. Take it easy, have a great weekend and see you around SUMO.
https://blog.mozilla.org/sumo/2016/01/15/whats-up-with-sumo-15th-january/
|
|
Air Mozilla: Paris Firefox OS Hackathon Presentations |
As an introduction to this weekend's Firefox OS Hackathon in Paris we'll have two presentations: - Guillaume Marty will talk about the current state of...
https://air.mozilla.org/paris-firefox-os-hackathon-presentations/
|
|
Yunier Jos'e Sosa V'azquez: Conoce los complementos destacados para enero |
Comenz'o un nuevo a~no y con 'el, te traemos nuevos e interesantes complementos para tu navegador preferido que mejoran con creces tu experiencia de navegaci'on. Durante los pr'oximos 6 meses estar'a trabajando nuevos miembros en el Add-ons Board Team, en la pr'oxima selecci'on desde Firefoxman'ia te avisaremos.
uMatrix es muy parecido a un firewall y desde una ventana f'acilmente podr'as controlar todos los lugares a donde tu navegador tiene permitido conectarse, qu'e tipo de datos pueden descargarse y cual puede ejecutar.
Esta puede ser la extensi'on perfecta para el control avanzado de los usuarios.
=> HTTPS Everywhere por EFF Technologists
Protege tus comunicaciones habilitando la encriptaci'on HTTPS autom'aticamente en los sitios conocidos que la soportan, incluso cuando navegas mediante sitios que no incluyen el prefijo “https” en la URL.
=> Add to Search Bar por Dr. Evil
Hace posible que cualquier p'agina con un formulario de b'usqueda disponible pueda ser a~nadido f'acilmente a la barra de b'usqueda de Firefox.
A~nadiendo la b'usqueda de un sitio web a la barra de b'usqueda
=> Duplicate Tabs Closer por Peuj
Detecta las pesta~nas duplicadas en tu navegador y autom'aticamente las cierra.
A nosotros nos encantar'ia que fueras parte del proceso de seleccionar los mejores complementos para Firefox y nos gustar'ia escucharte. ?No sabes c'omo? S'olo tienes que enviar un correo electr'onico a la direcci'on amo-featured@mozilla.org con el nombre del complemento o el archivo de instalaci'on y los miembros evaluar'an tu recomendaci'on.
Fuente: Mozilla Add-ons Blog
http://firefoxmania.uci.cu/conoce-los-complementos-destacados-para-enero-2016/
|
|
Tim Taubert: Build Your Own Signal Desktop |
The Signal Private Messenger is great. Use it. It’s probably the best secure messenger on the market. When recently a desktop app was announced people were eager to join the beta and even happier when an invite finally showed up in their inbox. So was I, it’s a great app and works surprisingly well for an early version.
The only problem is that it’s a Chrome App. Apart from excluding folks with other browsers it’s also a shitty user experience. If you too want your messaging app not tied to a browser then let’s just build our own standalone variant of Signal Desktop.
Signal Desktop is a Chrome App, so the easiest way to turn it into a standalone app is to use NW.js. Conveniently, their next release v0.13 will ship with Chrome App support and is available for download as a beta version.
First, make sure you have git and npm installed. Then open a terminal and
prepare a temporary build directory to which we can download a few things and
where we can build the app:
$ mkdir signal-build $ cd signal-build
Download the latest beta of NW.js and unzip it. We’ll extract the application
and use it as a template for our Signal clone. The NW.js project does
unfortunately not seem to provide a secure source (or at least hashes)
for their downloads.
$ wget http://dl.nwjs.io/v0.13.0-beta3/nwjs-sdk-v0.13.0-beta3-osx-x64.zip $ unzip nwjs-sdk-v0.13.0-beta3-osx-x64.zip $ cp -r nwjs-sdk-v0.13.0-beta3-osx-x64/nwjs.app SignalPrivateMessenger.app
Next, clone the Signal repository and use NPM to install the necessary modules.
Run the grunt automation tool to build the application.
$ git clone https://github.com/WhisperSystems/Signal-Desktop.git $ cd Signal-Desktop/ $ npm install $ node_modules/grunt-cli/bin/grunt
Finally, simply to copy the dist folder containing all the juicy Signal files
into the application template we created a few moments ago.
$ cp -r dist ../SignalPrivateMessenger.app/Contents/Resources/app.nw $ open ..
The last command opens a Finder window. Move SignalPrivateMessenger.app to
your Applications folder and launch it as usual. You should now see a welcome
page!
The build instructions for Linux aren’t too different but I’ll write them down, if just for convenience. Start by cloning the Signal Desktop repository and build.
$ git clone https://github.com/WhisperSystems/Signal-Desktop.git $ cd Signal-Desktop/ $ npm install $ node_modules/grunt-cli/bin/grunt
The dist folder contains the app, ready to be launched. zip it and place
the resulting package somewhere handy.
$ cd dist $ zip -r ../../package.nw *
Back to the top. Download the NW.js binary, extract it, and change into the
newly created directory. Move the package.nw file we created earlier next to
the nw binary and we’re done. The nwjs-sdk-v0.13.0-beta3-linux-x64 folder
does now contain the standalone Signal app.
$ cd ../.. $ wget http://dl.nwjs.io/v0.13.0-beta3/nwjs-sdk-v0.13.0-beta3-linux-x64.tar.gz $ tar xfz nwjs-sdk-v0.13.0-beta3-linux-x64.tar.gz $ cd nwjs-sdk-v0.13.0-beta3-linux-x64 $ mv ../package.nw .
Finally, launch NW.js. You should see a welcome page!
$ ./nw
Our standalone Signal clone mostly works, but it’s far from perfect. We’re pulling from master and that might bring breaking changes that weren’t sufficiently tested.
We don’t have the right icons. The app crashes when you click a media message. It opens a blank popup when you click a link. It’s quite big because also NW.js has bugs and so we have to use the SDK build for now. In the future it would be great to have automatic updates, and maybe even signed builds.
Remember, Signal Desktop is beta, and completely untested with NW.js. If you want to help file bugs, but only after checking that those affect the Chrome App too. If you want to fix a bug only occurring in the standalone version it’s probably best to file a pull request and cross fingers.
Great question! I don’t know. I would love to get some more insights from people that know more about the NW.js security model and whether it comes with all the protections Chromium can offer. Another interesting question is whether bundling Signal Desktop with NW.js is in any way worse (from a security perspective) than installing it as a Chrome extension. If you happen to have an opinion about that, I would love to hear it.
Another important thing to keep in mind is that when building Signal on your own you will possibly miss automatic and signed security updates from the Chrome Web Store. Keep an eye on the repository and rebuild your app from time to time to not fall behind too much.
https://timtaubert.de/blog/2016/01/build-your-own-signal-desktop/
|
|
Mike Hommey: Announcing git-cinnabar 0.3.0 |
Git-cinnabar is a git remote helper to interact with mercurial repositories. It allows to clone, pull and push from/to mercurial remote repositories, using git.
These release notes are also available on the git-cinnabar wiki.
Development had been stalled for a few months, with many improvements in the
next branch without any new release. I used some time during the new year
break and after in order to straighten things up in order to create a new
release, delaying many of the originally planned changes to a future 0.4.0
release.
git push.-f.GIT_SSH and GIT_SSH_COMMAND environment variables.git cinnabar now has a proper argument parser for all its subcommands.git cinnabar python command allows to run python scripts or open agit cinnabar rollback command allows to roll back togit cinnabar bundle command allows to create mercurial bundles,Up to before this release closing in, the master branch was dedicated to
releases, and development was happening on the next branch, until a new
release happens.
From now on, the release branch will take dot-release fixes and new
releases, while the master branch will receive all changes that are
validated through testing (currently semi-automatically tested with
out-of-tree tests based on four real-life mercurial repositories, with
some automated CI based on in-tree tests used in the future).
The next branch will receive changes to be tested in CI when things
will be hooked up, and may have rewritten history as a consequence of
wanting passing tests on every commit on master.
|
|
Air Mozilla: Web QA Weekly Meeting, 14 Jan 2016 |
This is our weekly gathering of Mozilla'a Web QA team filled with discussion on our current and future projects, ideas, demos, and fun facts.
|
|
Air Mozilla: Reps weekly, 14 Jan 2016 |
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.
|
|
About:Community: 32C3 Report – Chaos Time Zone |
Written by Valentin Schmitt.
Entering the CCH (Congress Center Hamburg) between Christmas and new year brings you somewhere else than Hamburg on Central European Time.
Most people you’ll meet will say they are from Internet (or the Internets, if they are funny), and for a few days you’ll live in -what a friend of mine called- Chaos Time Zone: a blurry mix of everyone’s time difference. Days are pretty shorts anyway and you’ll probably spend a lot of time under artificial light, so it won’t help your internal clock keeping on track. The organizers will gently remind you the 6,2,1 rule: 6 hours of sleep, 2 meals and 1 shower per day, that should keep you safe. You’ll probably meet a lot of great people, and will often have a hard time to decide which talk or workshop to go to.
This is the 32nd Chaos Communication Congress. Welcome, and have fun!
32C3 Chaos Communication Congress – Photo: Mario Behling
I looked for a screen printer, or anything to do myself a t-shirt with the message “Firefox OS is not dead!” on it, but very surprisingly regarding the variety of machines there, I couldn’t find any on site. I really wanted to do that, because most of the people I talked to about
Firefox OS answered me “But isn’t Firefox OS dead?”. I bet it won’t come as a surprise for you, as there was a lot of feedback from the community regarding what some might call “a PR disaster”. It just made it very clear to me that we (still) have to communicate a lot on this topic, and very loudly, because the tech news websites will be less likely to spread the word this time.
Once this detail (*cough*) was clarified, almost everybody I had the chance to talk to showed a lot of interested for the project, the only ones who didn’t were the hardcore Free Software enthusiasts, whom have been disappointed by Mozilla recent policy choices (like the tiles with
advertisement, or the DRM support in Firefox desktop), or the people who care less about software freedom and prefer an iPhone to a free (as in freedom) mobile OS.
Mozilla and Firefox at 32C3 with friends – Photo: Mario Behling
Mozilla has a pretty good image in the Free Software community, and the main reason why people never tried a Firefox OS device is only because they never had the chance to do so (not many devices marketed in Europe or the US, not many ports on mainstream phones). Fortunately enough, I had some foxfooding devices to hand out. The foxfooding program had a very positive reception, most people were happy to have the chance to try the OS, participate in sending data to Mozilla, file bugs, some were eager to develop apps, and try port the OS on their favorite phone or device (the RasPi got a bunch of them very excited).
More importantly, they really asked me how to flash a device, where to find the documentation to get started, how to file a bug. The people I handed a device to planned to show it to their colleagues, friends and fellow hacktivists, and were very excited to have phone with a hardware good enough to provide a responsive experience.
“Is there a Signal app or any secure messaging app?”
“Can I use Tor?”
“Can I keep OSM maps in cache?”
“Is there an app for WhatsApp?”
These were the questions I was asked the most. It’s pretty expected that the hackers community is looking for reliable privacy tools, but I was a bit surprised by the last question that still came up several times. 
An assembly is the name the Chaos Communication Congress gives to the physical place (typically a bunch of tables with a power outlet) within the CCH where people can gather to hack, share ideas and have self organized-sessions on a particular topic, or around a particular project, there were 277 registered this year.
Assembling Under The Lights – Photo: Hong Phuc FOSSASIA
With the Mozilla Assembly, we had several sessions (directly at the Assembly or in dedicated rooms) over these 4 days:
On average, there were around 15 Mozillians at the Assembly and a continuous flow of people from different community.
Other projects where Mozilla is involved were represented, like Let’s Encrypt, with a talk so successful that the conference room was full, and New Palmyra, for which Mozillians organized a session for 25 participants.
The hackers and makers communities have a real ethical and practical interest in a mobile or embedded OS that’s trustworthy and hackable, we bear similar values and Firefox OS is a great opportunity to strengthen the ties between us.
http://blog.mozilla.org/community/2016/01/13/32c3-report-chaos-time-zone/
|
|
Ben Kero: Installing RemixOS to an internal drive |
Your old pal syslinux is there to greet youAfter initially running RemixOS, the new Android build for PCs, I decided that I would rather play with booting it natively from my SSD instead of from a USB device. Performance should be better, it would free my USB thumb drive up for other duties, and it would make booting more convenient.
This turned out to be a relatively simple operation. What follows is my methodology for doing that. Please note that these instructions assume you are running Linux.
In my machine I installed a second SSD to increase my available space, and for projects that involve taking an entire disk. Using this as a boot device I’m able to natively boot RemixOS.
$ mkdir $HOME/remixos $ cd $HOME/remixos $ wget https://otacdn.jide.com/ota/Remix_OS_for_PC_64_B2016011201_Alpha.zip
$ unzip Remix_OS_for_PC_64_B2016011201_Alpha.zip
$ sudo mount -o loop Remix_OS_for_PC_64_B2016011201_Alpha.iso /mnt $ sudo mkdir /mnt2 $ sudo mount /dev/sdb2 /mnt2 $ sudo rsync -av /mnt/* /mnt2/
$ sudo apt-get install syslinux $ sudo mv /mnt2/isolinux /mnt/syslinux $ sudo mv /mnt2/syslinux/isolinux.cfg /mnt2/syslinux/syslinux.cfg $ sudo syslinux /dev/sdb2
$ sudo dd if=/usr/lib/syslinux/bios/mbr.bin of=/dev/sdb
$ sudo umount /mnt $ sudo umount /mnt2 $ reboot
After rebooting, select the drive as a boot device. You should be greeted by the same boot menu as if you booted from USB.
|
|
Justin Dolske: Hardware GIF |
About a year and a half ago, I started work on a fun little project. I’ve been dabbling with it on-and-off, and now it’s finally finished. So I thought I’d post a retrospective, as the process and challenges along the way were just as enjoyable as the end result.
It all began with a tweet that randomly popped into my head one day:
How do I convert between metric and imperial fucks-given?
— Justin Dolske (@dolske) May 15, 2014
Sean Martell replied with a classic GIF, and something about the combination of tweets made me start itching to build a real, physical version. The basic plan came together quickly, but I didn’t realize that it would be a long and meandering path through researching GIFs, vintage electronic hardware, nitpicky laser printer output, metalwork, 3D modeling/printing, and more.
I think the finished result is pretty good:
GIVE-A-FUCK-O-METERHere’s a bit more about the process of building it.
Research and Foundation
The first thing I had to do was some due-diligence: what are the essential qualities of meme-meter? After extensive research on every such GIF I could find, I knew exactly what I wanted. A meter with a retro feel, a realistic face that was scientific and precise, and a needle that jittered around the bottom of the scale to indicate approximately “zero fucks given”. In metric.
All the GIFsThe next day, I jumped on Ebay to scope out some vintage analog meters, and got unbelievably lucky: a pair of Triolab voltmeters from the early 1960s for just $16 (plus shipping). One was rather ugly and worn, but the other was absolutely perfect. Retro, with just enough wear to be authentic, yet in excellent condition. A compact 4-inch cube with a hefty weight makes it perfect for desktop display. And, oh, the details – industrial black crinkle-paint finish, sturdy knobs, brass and stainless steel screws, and a classic aluminum product nameplate.
The insides are equally amazing. Lots of colorful antique components (even a vacuum tube!) on a wire-wrapped board, complete with that distinctive “old electronics smell” that may or may not be known to the state of California as causing cancer. Even the cabling just oozes quality, neatly bundled with lacing that’s rare to see today outside of aerospace applications.
Old-skool componentsAs an added bonus, there’s an instrument calibration label on the top from “Martin Marietta Corporation, Aerospace Division,” certifying that it’s within 2% of manufacturer’s specs as of November 1963. Plus an earlier ink stamp from June 1961. They help make it feel like it fell into a time warp straight from a mid-century laboratory. (I’d love to know what this meter was originally used for – Martin Marietta was probably best-known for the Titan family of rockets and ICBMs, so something involving them might be a good guess.)
Calibration sticker and stampUnfortunately, the paper sticker was in desperate need of conservation; it was starting to degrade and was very fragile. One corner was missing, and another was barely hanging on. Not too surprising, as it was a simple tag meant to be replaced after 6 months, and not designed for a 50-year lifetime. To fix it I used some adhesive to fasten the loose edges, and a clear “Ultra Matte” polyurethane paint to stabilize the surface. I was pleased with the result, which maintains the appearance of plain (unpainted) paper. [Aside: the tech who originally applied the label was very sloppy with the glue, if you look closely that’s what you see around the edges, not my work!]
Face Time
My first major undertaking was to design a new faceplate for the meter. I used Acorn to draw the scale using vector lines and circles; most of the work was tedious but straightforward. One handy trick was to scan the original faceplace at 600dpi on the office scanner/copier, and use that as a template for accurate physical sizing.
I spent a disturbing amount of time in the vintage typeface rathole. My first thought was to use Futura, which is commonly used in aerospace instrumentation (notably, the flight controls on Apollo and the Space Shuttle). But it didn’t feel quite right – ironically(?) too modern. I also looked through piles of other typefaces, named and unnamed, from hobbyists who recreate flight controls on vintage aircraft. In the end, I just used the modern Avenir Next Condensed font that comes with OS X for the main text. It’s a faithful nod to the original meter faceplace. I also matched typefaces as best I could for the smaller labels, and redid the “triolab” logo to make it sharper than the original scan.
Once printed, I carefully disassembled the analog meter, flipped over the original aluminum faceplate, and affixed my version with some spray mount.
Before and after. Well, after and before. You know what I mean.Laser Printer Resolution
Attention to detail was important to me on this project, but one issue I didn’t catch until too late (and never fully resolved) was print quality. Despite my work being in resolution-independent vector format, I consistently got suboptimal output when printing. Here’s an example of a 10pt capital letter “K” printed 3 different ways, photographed through a USB microscope:
Bad K, bad K, ok K.On the left is output from Acorn, as printed on my 10 year old home HP LaserJet 1012 (600dpi), and in the middle as printed on a new Ricoh C2503 (1200dpi). The rightmost is the same letter “K” printed on my HP, but using TextEdit instead of Acorn. I tried myriad combinations of printing to intermediate formats, source bitmap resolutions, and printer settings, but the results were always the same… Anything coming from Acorn or Photoshop came out with bumpy edges, while output from a text editor was crisp.
My assumption is that something in the pipeline was rasterizing everything, and the printer was just doing it’s best to blithely print a greyscale bitmap with halftones. Eventually I got slightly better, but not great, output by printing to an absurdly high-resolution PDF, filtering to B&W and downsizing with ImageMagick, and then printing the final 1-bit depth image. I’m curious if a dedicated vector program like Adobe Illustrator would have made this Just Work, or if there’s even any good way to do this. Back in the day one could have hand-crafted some PostScript/PCL for this, but I’m not sure exactly how modern printing pipelines work.
Who knew that 1200dpi wasn’t enough for good black-and-white output?! (This guy, apparently.)
Electronics
The electronics on the new meter are slightly overkill, but are what I had sitting around. At the core is a Digispark (basically a tiny Arduino clone), with an IO port expander and a custom protoboard for gluing everything together.
New-skool componentsThe Digispark controls the meter through a PWM output. Analog meters are driven by rather small currents, and I needed just 206 microamps to drive it full-scale, which is trivial for the microcontroller to provide directly. At 4.65v that needs about 22k
|
|