# apt-get install -t jessie-backports drupal7-mod-drucall

http://danielpocock.com/improving-drucall-and-jscommunicator-user-interface

I was invited to join a panel about Open Source and Music in Loop, an slightly unusual (for my “standards”) event. It wasn’t a conference per se, although there were talks. Most of the sessions were panels and workshops, there were very little “individual” talk tracks. Lots of demos, unusual hardware to play with in the hall, relaxed atmosphere, and very little commercialism—really cool!

Before I agreed to join them, I spoke to Juanpe Bolivar, the host of my panel, and made sure he was aware of why I didn’t actually want to join a panel, because I had been in a few so far and they were always horrendous due to the power dynamics in place. I explained all my concerns to him, and suggested tons of ideas to make things better, and he listened and put them in practice! So that was really good, and made me feel good about the event. It also helped that I knew some people who work for Ableton or who were connected to them, so I trusted them. Also they mentioned the code of conduct early on and they mentioned it during the opening event as well—with the room full of people.

Their organisation for booking travel and accommodation was super great as well: they helped me be time efficient by booking the most convenient flights, and the hotel they reserved was very good! Which I super greatly appreciated after having been travelling so much recently… the last thing you want is being placed on a crappy hotel!

When I was waiting for the flight to Berlin I noticed that James Holden was on the same flight too, because he was joining Loop as well. James Holden! OK maybe you don’t know him, but he’s a quite popular DJ who’s also an author/producer and instigator of various experimental acts, and also really chill and loves to share how he does things and what his process is. So he was there in front of me eating a croissant, and of course I would NOT tell him anything because eating a croissant is one of life’s sacred moments. You don’t want to interrupt anyone when they’re eating a croissant. It just breaks the magic and everything gets awkward, with pieces of pastry going all over. No, just don’t do it.

So I didn’t say anything.

But when we landed I got welcomed by a representative from Loop. She was very nice and told me we should wait until we met James and his colleague Camilo Tirado and then we would head out to get a taxi to our hotels. So I had a chance to actually speak to James! I said “hi” like a shy child, and then I told him I had seen him play at a long-closed club in London, many years ago, and he said something like “Ahh yeah when we were young!”, and asked me what I did! So yeah, exactly the down to earth person I expected. Camilo was also super nice, and I got to talk to him later on about musical composition, how you play Indian music, universities and schools, etc.

This was just a bit of what was to happen during the event: you would be listening to some artist talk about their process and then it was just very natural to come and talk to them afterwards, and they would also ask what were you doing. The whole event was set up with the goal of getting artists to make connections and not work alone, as the event premise is that making music has turned into a very solitary act nowadays and we spend so much time in front of our computer screens in contrast to playing with other artists, etc. It was a bit funny for me as my “main job” is not as a musician, but I’m “enabling” people’s music creations on the web and also make my own music from time to time, so it was interesting to see that they were really accepting of my ‘hybrid’ situation, and very excited about the notion of me enabling other people on the web, whereas generally people in tech are way more condescending and exclusivist (“oh, you’re not a real developer!”, etc).

As you can see I was semi unconsciously trying to extrapolate this to our “industry”; my brain was making comparisons all the time. I noticed little things like:

• the drinks at the bar were not free, and no one batted an eyelid; they just paid for them and also there were zero incidents with drunkards harassing me. Correlation? Causation?
• there was no t-shirt for the event, the only event themed t-shirts were worn by event people
• picking the swag bag was optional, they didn’t give it to you automatically. And the bag essentially just had a leaflet with the program and a notebook.

The panel

After the opening, Juanpe brought us to dinner to a nice Vietnamese place so we could get to know each other’s background a little bit more before the panel happened. I hadn’t met my co-panelists before, and I was a bit scared that they would be “more open source than ye” kind of people, as they essentially worked in Linux Audio stuff, but they were excellent people and really easy to get along with. Soon my concerns evaporated.

For reference, they were:

• Gianfranco Ceccolini, he works on a programmable pedal device called the MOD: it’s a device which has an embedded computer running Linux, and you can download effects and install them on it. Their business model consists in that they provide precompiled binaries so they are convenient for musicians that just want to get music done
• Marije Baalman, she is an artist and also developer for STEIM, a company that builds custom instruments and stuff for artists. They use Super Collider and Linux, and she was also involved in the Linux Audio conference.
• Paul Davis, he’s the lead developer of Ardour which is a very popular open source audio workstation (think Garage Band, but free), and also JACK which enables you to pipe and control audio in your system (without|with very low) latency (like CoreAudio etc, but again, free, and multiplatform). He also happens to be the 2nd employee Amazon ever hired so he’s been in the tech industry for a while too!

http://soledadpenades.com/2015/11/18/on-loop-2015/

Hi, mozillian! Friday, November 27th, we will host a new Testday for Firefox 43.0 Beta 7, I bet you did not see this coming

https://quality.mozilla.org/2015/11/firefox-43-0-beta-7-testday-november-27th/

(via https://www.youtube.com/watch?v=Wl5Uo5cMcsw)

http://sietch-tabr.tumblr.com/post/133451473977

the following changes have been pushed to bugzilla.mozilla.org:

• [1221998] Make sure localconfig is generated deterministically
• [1219767] Explicitly load extensions at Bugzilla->login
• [1221423] unable to impersonate users when 2fa is enabled
• [1181637] Update Req Opening Process (Cost Center list on 2015-07-08)
• [1223495] String handling bug in form.creative on BMO
• [1223669] don’t scroll to the top of the page when clicking on the resolution buttons
• [1209625] MozReview API Keys should use a more specific error message
• [1223590] Unable to login to bugzilla via login to github (fresh bugzilla account)
• [1224620] Update VP list in Recruiting Product
• [1187429] Remove the WebOps Request Form
• [1225249] module subtitles should be the same size as other text on the page (13px)

discuss these changes on mozilla.tools.bmo.

https://dlawrence.wordpress.com/2015/11/18/happy-bmo-push-day/

Say you’ve read my earlier post on Firefox Telemetry and want to make your own plots like https://telemetry.mozilla.org does. Well, like almost everything Mozilla does, that website is open source, so we can just copy what it does… except it’s a little convoluted. It needs to support a range of requirements and configurations, after all.

But your needs are just yours, so wouldn’t it be nice if there were something a little more direct?

Enter telemetry-wrapper.js. Simply include it and its dependencies in your HTML and then call it like so:

TelemetryWrapper.go(params, element);

Then ‘element’ will suddenly (after a few seconds to collate and render the data) contain one or more plots corresponding to ‘params’.

Want to see GC_MS compared by e10sEnabled setting on Nightly 44?

TelemetryWrapper.go({
  channel: "nightly",
  version: "44",
  metric: "GC_MS",
  compare: "e10sEnabled",
}, document.body);

(e10s is looking like a win on this metric, though part of the sample population self-selected so we can’t be sure. Await blog posts from other quarters on A/B tests we’re conducting.)

How about the top three plugins activated in Firefox 42?

TelemetryWrapper.go({
  channel: "release",
  version: "42",
  metric: "PLUGIN_ACTIVATION_COUNT",
  keyLimit: 3,
}, document.body);

(no one is surprised that the top one is Flash and that most people only use it the once. But googletalk has an odd shape to it, being activated exactly twice by clients more often than any other frequency…)

The technical details are in the README. Use and reuse it to ask and answer questions about Firefox Telemetry data!

:chutten

https://chuttenblog.wordpress.com/2015/11/18/single-api-firefox-telemetry-plots-telemetry-wrapper-js/

Sam Piggot presents his experience in releasing The Dojo app on a tight schedule. This talk has been given as part of the Swift LDN...

https://air.mozilla.org/sam-piggott-the-dojo-story-swift-ldn-20151116/

Radek described his experience and process to build a statically type API in Swift. This talk has been given as part of the Swift LDN...

https://air.mozilla.org/radek-pietruszewski-statically-typed-swifty-apis-swift-ldn-2015116/

Emily Toop speaks about the hacks and tricks the Fennec iOS team went through to produce Firefox for iOS using WKWebView. This talk has been...

https://air.mozilla.org/emily-toop-wkwebview-made-me-do-it-swift-ldn-20151116/

This Thursday, my colleague Mike Harsh and Keith Rowe (@krow) from Microsoft’s Windows and Devices Group invite you to the Square Pig in London for some drinks and a chat. These two program managers are leading efforts to make Windows-based machines a better place for web development.

I’ve put up a small web site with the info of the meetup and there’s also a Lanyrd page. Many thanks also to London Webstandards for banging the drum.

Whilst I am not affiliated with this group and I can’t be there as I am on my way to JSConf Asia to present, I’d love to see a lot of people go and talk to them. This is a genuine offer to improve what Windows has for web developers and I already gave them quite a bit of feedback on the matter (I am a Mac user…).

I’ve been worried about our Mac fixation as web developers for a while. We preach about supporting all platforms as “it is the web” but a lot of our tooling and best practices are very Mac/Command Line centric.

I know this is a bit last minute, but as it is with London Pubs, you have to spring a grand to get the room for the evening, so please show up and at least make sure this expense ends in the form of food and drinks inside people who Microsoft can learn from.

https://www.christianheilmann.com/2015/11/17/meetup-in-london-why-is-windows-not-your-platform-of-choice/

When I started cycling into the office this year, I said I would probably end in November or December when it got too cold and wet.

Last night was really, cold, windy and I had so many near misses with cars, pedestrians and signs. The worst part was as usual the Second Narrows bridge which was really, really windy. A bus hit a puddle on the bridge and the wall of water went over the barricade and hit me. Coming off the bridge the ramp is covered in wet slippy composting leaves and when you are trying to avoid that unlit pedestrian, in the dark on skinny road tires with frozen fingers in driving rain....

So I'm done.

I cycled for about 9 months of the year from Deep Cove to the office for several days a week. Not too shabby. The real difference this year was training for the Fondo, which meant that in the summer when I cycled five days a week to the office, that's 170 km a week, I wasn't that tired but wanted to do more and started detouring over the Lions Gate bridge. I hit over 300km one week.

According to Strava I cycled 3,842km over 1712h this year. That's not too shabby. Next year I'm aiming for two Fondo's. But for now its time to go to the gym more and do more curling and snowboarding.

http://www.agmweb.ca/2015-11-17-a-year-in-cycling/

In the next few blog posts I want to cover some areas for improvement for Rust macros. I'll drill down into one topic at a time. I'll propose solutions, but not in RFC-levels of detail. I hope to get lots of early feedback this way, rather than doing all the design myself and having a 'big-bang' RFC. A lot of the macro issues are inter-related, so some of the details in early areas won't get fleshed out until later.

I'm going to start with concatenating idents in macros and using macros as idents. This is a fairly small thing, but is an irritating thing for many macro authors. The problem space has been expored already, see the references section at the end for links to issues and a previous RFC.

Motivation

It is often desired to merge two (or more) identifiers to make a new one in a macro. For example, a macro might take an identifier and create two functions - e.g., foo and foo_mut from foo. This is related to the issue of creating new identifiers in macros.

Currently we support this by using the concat_idents macro. There are two main problems with it - it is not very smart with hygiene, and it is not very useful since macros can't be used in ident position; so although it can synthesis idents, these can only be used as expressions. E.g., although we could access variables called foo and foo_mut given foo, we can't generate functions with these names or even call functions with those names.

The hygiene issue is that concat_idents creates a fresh ident. Essentially, the ident is only in the scope of the macro which created it. Generally, you want to inherit the hygiene context from one of the source idents.

Proposed solution

• deprecate concat_idents! - without proper hygiene support, it is not suitable for stable use,

• allow macros in ident position (see below for details),

• provide libraries for manipulating hygiene contexts in procedural macros (see later blog posts),

• provide a library of procedural macros which can concatenate identifiers with various different kinds of hygiene results (see below for details).

Macros in ident position

The concept is pretty simple - anywhere we accept an identifier in current Rust, we would accept a macro. This includes (but is not limited to): variable declarations, paths, field expressions, method and function calls, item names (functions, structs, etc.), field names, type names, type variables (declaration and use), and so forth. I propose that this facility is only available for 'new' macros, partly for technical reasons (see below, hygiene and types) and partly as a carrot to move people to the new macro system.

Examples, if foo is a macro: x.foo!() (field access), x.foo!(bar)() (method call), fn foo!(baz)(x: T) { ... } (function declaration).

If a macro occurs in expression or pattern position, then there is the question of whether it should be parsed as a macro in expression position or a macro in ident position as a path which is an expression (similarly with patterns). I think we can always choose the least specific option (i.e., expression rather than ident position) because we parse the macro body after expansion, so if it is an ident, the parser will wrap it to make an expression (if we assumed it was an ident, but it was a non-ident expression, we would be stuck). This only works for procedural macros if their output is tokens rather than AST (see later blog posts).

I believe parsing should not be too affected - after parsing an ident, we simply need to check for an !. Any AST node that contains an Ident must instead contain a new enum which can either be an Ident or a macro in ident position.

I don't believe there are issues with expansion or hygiene, expansion should work the same as for macros in other position and hygiene should "just work". One might imagine that since idents are the target of the hygiene algorithm, that creating new ones with macros would be difficult. But I don't think this is the case - the macro must expand to an ident only (or further macros that expand to an ident), and the hygiene context for that ident will be due to the macro which creates it and the expansion itself (see note on sets of scopes algorithm below). We might need to adjust the hygiene context of the ident in the macro where it is created, but that is a separate issue, see below. Note that in nearly all cases, users of a macro that produce an ident will need to pass some context to the macro to make the produced ident accessible.

There are some undecided questions where macros supply idents in items, types, and other places where we don't currently support hygiene. I propose to only support macros in ident position with new macros, which should be hygienic where current macros are not. This should make things easier. Exactly how macros in ident position interact with item hygiene is an open question until we nail down exactly how item hygiene should work.

Note: sets of scopes

I have been thinking of changing our hygiene algorithm to the sets of scopes algorithm. I won't go into the details here, but I think it will help with a lot of issues. It should mostly be simpler than the mtwt algorithm, but one area where it will add complexity is with use-site scopes. These are added to the sets of scopes in order to handle recursive macros, but when a macro contributes to a new binding (I believe this will mean macros in pattern position and macros in ident position where the ident introduces a binding), then we must be careful not to add use-site scopes. This point needs more consideration, but I think it will be OK - we just have to be careful about these scopes.

Drawbacks and alternatives

I think macros in ident position look ugly - having double sets of parentheses (in function calls) or parentheses where there wouldn't normally be is confusing to read. It also makes code harder to read in general, since names are an essential way we link parts of code together. Having names be macro generated makes code harder to make sense of. It's also confusing for tools.

One alternative would be to only allow macros in ident position inside macro definitions - this should address most use cases, without making general Rust code harder to read (macros are already harder to read, so there is less of an impact). I think I favour this alternative, although I am very keen to get others' opinions on it.

Another alternative would be to come up with some new syntax especially for use in ident position - this might be less ugly and give more of a hint of the generated name. However, since we must be able to pass arguments to macros, I'm not optimistic that this is possible. Furthermore, it is more syntax and thus a bigger language which is confusing in its own way.

Library macros for concatenation

This section will be a bit hand-wavey for now, we need to decide on the fundamental APIs for allowing procedural macros to interact with the hygiene system before we can settle the details.

I expect we want a fundamental create_ident! macro (or create_ident function) which takes a string name and a syntax context (probably some token which carries it's hygiene information, more on exactly how this works later). E.g., create_ident!(foo, "bar") would create an ident with the name bar and a hygiene context taken from foo.

We would also have fresh_ident! which would create an ident from a string name with a fresh hygiene context (similar to gensym'ing) and new_ident! which does the same thing but with an empty hygiene context (i.e., it gets only the context due to the expansion of the macro where it is created). The difference between the two being that two idents created with fresh_ident! would have different contexts, but two created with empty_ident! would have the same contexts.

We then provide convenience macros which take a list of idents and/or an ident (for its hygiene context) and a list of things which produce strings, and produce a new ident with either hygiene contexts taken from the first ident, or a seperately specified object, or a fresh context. Obviously, we need to make this a bit more concrete.

Example

struct Foo {  
    a: A,
    b: B,
}

macro! def_getters {  
    ($f: ident, $t: ident) => {
        fn concat_idents_with!($f, "get_", $f)(&self) -> &$t {
            &self.$f
        }
        fn concat_idents_with!($f, "get_", $f, "_mut")(&mut self) -> &mut $t {
            &mut self.$f
        }
    }
}

impl Foo {  
    def_getters!(a, A);
    def_getters!(b, B);
}

fn main() {  
    let f = Foo { ... };
    println!("{}", f.create_ident!(f, "get_a")());
}

Where concat_idents_with!($f, "get_", $f, "_mut") expands to an ident with name get_$f_mut and hygiene context taken from $f. Note that in this case concat_idents_with! is used in a binding context, so the hygiene context (under a set of scopes model) should not include a use-site scope.

The use of create_ident in main is a bit silly, it's just for demonstration purposes: f.create_ident!(f, "get_a")() has exactly the same meaning as writing f.get_a().

References

concat_idents tracking issue

macros in ident position issue

macros in ident position RFC

http://www.ncameron.org/blog/untitledconcat_idents-and-macros-in-ident-position/

Lots of fun! I’m serious.

http://www.bitstampede.com/2015/11/16/five-word-movie-review-terminator-genisys/

Hey everyone!

On November 13th, we held Firefox 43.0 Beta 3 Testday and it was another notable event – we had quite a number of participants this time too

https://quality.mozilla.org/2015/11/firefox-43-beta-3-testday-results/

During October 2015 the curl web site sent out 1127 gigabytes of data. This was the first time we crossed the terabyte limit within a single month.

Looking at the stats a little closer, I noticed that in July 2015 a particular single package started to get very popular. The exact URL was

http://curl.haxx.se/gknw.net/7.40.0/dist-w32/curl-7.40.0-devel-mingw32.zip

Curious. In October it alone was downloaded more than 300,000 times, accounting for over 70% of the site’s bandwidth. Why?

The downloads came from what appears to be different locations. They don’t use any HTTP referer headers and they used different User-agent headers. I couldn’t really see a search bot gone haywire or a malicious robot stuck in a crazy mode.

After I shared some of this data over in our IRC channel (#curl on freenode), Bj"orn Stenberg stumbled over this AVG slide set, describing how a particular malware works when it infects a computer. Downloading that particular file is thus a step in its procedures to create a trojan that will run on the host system – see slide 11 for the curl details. The slide also mentions that an updated version of the malware comes bundled with the curl library already, which then I guess makes the hits we see on the curl site being done by the older versions still being run.

Of course, we can’t be completely sure this is the source for the increased download of this particular file but it seems highly likely.

I renamed the file just now to see what happens.

Evil use of good code

We can of course not prevent evil uses of our code. We provide source code and we even host some binaries of curl and libcurl and both good and bad actors are able to take advantage of our offers.

This rename won’t prevent a dedicated hacker, but hopefully it can prevent a few new victims from getting this malware running on their machines.

Update: the hacker news discussion about this post.

http://daniel.haxx.se/blog/2015/11/16/the-most-popular-curl-download-by-a-malware/

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.

Updates from Rust Community

News & Blog Posts

• Redox is serious. Redox is an upcoming OS written in Rust.
• Index 1,600,000,000 keys with Automata and Rust.
• Writing an OS in Rust: Allocating frames.
• Making Popcorn: Adding a disk to a Rust Rumprun Unikernel.
• Rust in detail: Sending and receiving messages.
• Rust impressions from a C++/D programmer, part 1.
• Rust impressions from a C++/D programmer, part 2.
• Bare metal Rust 2: Retarget your compiler so interrupts are not evil.
• This week in Servo 41.

Notable New Crates & Projects

• rustfmt is now part of Rust Nursery.
• Leaf. Open Machine Intelligence Framework.
• lrs. An experimental, linux-only standard library.

Updates from Rust Core

95 pull requests were merged in the last week.

See the triage digest and subteam reports for more details.

Notable changes

• Add a MIR pass to simplify the control flow graph.
• BinaryHeap: Simplify sift down.
• Allow none Sized types in assert_eq!.
• Add -Zinput-stats.
• Suggest mut for mutability errors.
• Cargo: Add a rustdoc subcommand.
• Syntax: Merge parsing code for structures and variants.
• Report errors at macro definition, not expansion.

New Contributors

• corentih
• Danilo Bargen
• Eric Findlay
• Erik Davidson
• Kohei Hasegawa
• Sebastian Hahn

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

No RFCs were approved this week!

Final Comment Period

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:

• Amend recover with a PanicSafe bound.
• Document and expand the open options.
• Allow overlapping implementations for marker traits.
• #[deprecated] for Everyone.
• Improvements to the Time APIs.
• Define the general semantics of intrinsic functions.
• Add an alias attribute to #[link] and -l.

New RFCs

• Add #[repr(align = "N")].
• Add CommandExt::{exec, before_exec}.
• Improve Cargo target-specific dependencies.
• Transparently use verbatim paths on Windows.

Upcoming Events

• 11/17. Rust Hack and Learn Hamburg.
• 11/18. Rust Los Angeles Monthly Meetup.
• 11/19. Wellington Rust Meetup.
• 11/25. Columbus Rust Society.
• 11/25. RustBerlin Hack and Learn.

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.

fn work(on: RustProject) -> Money

• Research Engineer - Servo at Mozilla.
• Senior Research Engineer - Rust at Mozilla. Join the core Rust team!
• Open Source Software Engineer at MaidSafe.
• Systems Engineer at IronNet Cybersecurity.

Tweet us at @ThisWeekInRust to get your job offers listed here!

Crate of the Week

This week's Crate of the Week is Hyper which offers a Rust HTTP(S) implementation for both clients and servers.

Thanks to DanielKeep for this week's suggestion. Submit your suggestions for next week!

http://this-week-in-rust.org/blog/2015/11/16/this-week-in-rust-105/

Last week I looked into a couple of Gecko leaks using rr. One fun aspect of using rr is discovering new debugging techniques. "What's the best way to use a record-and-replay debugger to track down memory leaks?" is a very interesting question. Maybe no-one has tried to do this before.

XPCOM_MEM_LEAK_LOG uses instrumentation to count object constructors and destructors and report any mismatches. That tells us immediately which classes of objects leaked. My next step was to identify the address of a leaked object, preferably one that is the root of an ownership tree of leaked objects. In my particular case I chose to investigate a leaked nsWindow, because only one was leaked and I guessed (correctly, as it turns out) that it was most likely to be the root of the leaked object tree.

Finding the address of the leaked nsWindow was easy: run the program with breakpoints on the nsWindow constructor and destructor, set to log the object address and continue. The constructor with no matching destructor has the address of the leaked object. At process exit I could inspect the window object and see that indeed it still existed with refcount 1.

My next move was to use a similar technique to log addref/release operations on that window. This is similar to what you'd get with Gecko's built-in trace-refcount instrumentation, but produced a lot of data that was hard to analyze. I realized the leaked reference to the window probably corresponds to a pointer to the window in memory when the process exits. So I added a real-tid command to rr to print the real thread-id of a replaying process, and wrote a small program to walk /proc/.../maps and /proc/.../mem to search all process memory for the pointer value. This worked very well and showed just two addresses where the pointer occurred.

The next problem was to figure out what those addresses belong to. I futzed around a bit before finding the correct approach: set hardware write watchpoints on those addresses and reverse-execute from the end of the process to find the writes that stored those addresses. This told me immediately where and why each reference was being stored, and if it was a strong reference. This made the bug obvious.

A lot of this could be more automated. It would be particularly interesting to grab the XPCOM_MEM_LEAK_LOG output and process it to automatically output the "leak roots" --- leaking references that are not contained in objects that themselves leaked. If there are no leak roots then instead there must be at least one cycle of strong references, which we can output.

http://robert.ocallahan.org/2015/11/debugging-leaks-with-rr.html

On Saturday I participated in a protest march for the first time ever --- against the TPPA. I support lowering trade barriers, but the TPPA has a lot of baggage that I strongly dislike, such committing member nations to a dysfunctional United States-esque intellectual property regime, and sovereignty-eroding "investor-state dispute settlement". The biggest prize for New Zealand would have been free access to foreign dairy markets, but that was mostly not realized, so it seems like a bad deal for us.

Unsurprisingly there were a lot of different sorts of people involved. Many of them espoused themes I don't agree with --- knee-jerk anti-Americanism, "Socialist Aotearoa", general opposition to free-market economics. That made it more fun and interesting :-). I think it's very important that people who disagree about a lot of things can still work together on issues they do agree about.

http://robert.ocallahan.org/2015/11/tppa-protest.html

I made this presentation at Seneca’s FSOSS a few weeks ago; some of these ideas have been rattling around in my brain for a while, but it was the first time I’d even run through it. I was thoroughly caffeinated at the time so all of my worst verbal tics are on display, right as usual um right pause right um. But if you want to have my perspective on why free and open source software matters, why some institutions and ideas live and others die out, and how I think you should design and build organizations around your idea so that they last a few hundred years, here you go.

There are some mistakes I made, and now that I’m watching it – I meant to say “merchants” rather than “farmers”, there’s a handful of others I may come back here to note later. But I’m still reasonably happy with it.

http://exple.tive.org/blarg/2015/11/15/the-thousand-year-roadmap/

http://danielpocock.com/migrating-data-from-windows-phones