Rolandt

I have been thinking a lot about aptitude.

It began last year, when I was asked to teach knitting to groups of community residents. Having worked as an academic instructor in a past life, I felt fairly comfortable taking on the task. I set a curriculum, with a plan to cover a series of basic skills within a specific time frame. I imagined beginning each session by demonstrating a new technique, which we would then all practice and master as a group.

What I soon discovered however, was that even in small groups, the ability to pick up these skills differed so dramatically from one person to the next it was impractical to hold the classes in the manner I had envisioned. What one person mastered intuitively before I’d finish explaining it, another would be unable to replicate even after repeated physical demonstrations.

After that, I altered the format of my teaching to be less class-like, and more like personalised sessions held in a group setting. I spent more time with each student individually, and accepted that everyone would learn on their own timeline - only marveling, now and again, at the difference in the rate at which this happened. All the students started from scratch. All were equally enthusiastic; all genuinely tried their best. And yet, by the end of the programme, some would whiz past my originally envisioned Basic Skills curriculum and become full fledged knitters, while others would still struggle with holding their tools correctly.

I was witnessing the phenomenon of aptitude. And it was only when confronted with it so directly, that it truly sunk in what a huge role it plays in any activity involving skill - including, of course, cycling.

In contrast to my aptitude for the fibre arts, it is fair to say that my aptitude for cycling is poor. Now in my 9th year of riding a bicycle as an adult, I am only starting to approach the level of handling skills that most cyclists I know attain within their first 6 months of riding. That is pretty poor indeed. And it's not as unusual as some might think.

On a regular basis, I receive correspondence from cyclists frustrated by their lack of 'progress.' They love cycling, but just aren't getting 'good' at it, no matter how hard they try. The folks at the bike shop look at them strangely, when they say how long they've been cycling yet ask for the saddle to be lowered. Their friends have moved on to do challenging rides without them. Will they ever improve? Should they just admit defeat and call it quits? Sadly, I suspect that many do.

As a cycling culture, we tend to classify cyclists on a scale ranging from Beginners to Experienced. The assumption there, is that what stands between a person having poor mastery of cycling skills and excellent mastery of cycling skills, are experience and practice.

In reality, that is often not the case. There exist dedicated cyclists with decades of experience, and poor cycling skills. Likewise, new cyclists can become proficient at these same skills within a very short time span.

That there is no allowance for aptitude in our narrative of cycling is problematic.

When the experiences of those who do not adhere to the practice = mastery formula are undermined or dismissed - be it in bike shops, on bicycling forums, in the comment sections of cycling blogs, or in casual conversation  - a disservice is done not only to those people. A disservice is done to the concept of cycling in of itself - by smoothing away its nuanced contours, and simplifying it into something more rigid and bullish, less multifaceted and full of possibilities, than it really is.

Because if we think abut it... The very fact that those of us who aren't 'good' at cycling still love it, and want to do it, and are able to do it, is fascinating, and wonderful, and a testament to what an engaging, beautiful, versatile activity riding a bicycle is.

Oftentimes my poor aptitude for cycling has made me feel like an outsider in the very culture and industry I was writing about. It has not, however, deterred me from persisting with cycling, enjoying cycling, and sharing my experiences of cycling with others.

My hope is that over time we can find a way to reframe our narrative of cycling to be more reflective of, and sensitive to, the wide range of aptitudes that exist among us. And that all those who ride a bicycle - in any way at all - feel free to enjoy it on their own terms.

Rob Shields, October 27 2017.  Space and Culture Research Group On October 27 Rob Shields presented asking, ‘What are the social effects of built infrastructure?’ Changing public interaction with civic infrastructure accumulates to changes in Canadian social forms. Infrastructure affects social integration, accessibility, and inclusiveness. Infrastructure choices affect the relations of core and periphery, and … Continue reading The Social Life of Infrastructure →

Security researchers have recently uncovered security issues known as Meltdown and Spectre. These issues apply to all modern processors and allow attackers to gain read access to parts of memory that were meant to be secret. To initiate a Spectre- or Meltdown-based attack, the attacker must be able to run code on the victim’s processor. WebKit is affected because in order to render modern web sites, any web JavaScript engine must allow untrusted JavaScript code to run on the user’s processor. Spectre impacts WebKit directly. Meltdown impacts WebKit because WebKit’s security properties must first be bypassed (via Spectre) before WebKit can be used to mount a Meltdown attack.

• WebKit relies on branch instructions to enforce what untrusted JavaScript and WebAssembly code can do. Spectre means that an attacker can control branches, so branches alone are no longer adequate for enforcing security properties.

• Meltdown means that userland code, such as JavaScript running in a web browser, can read kernel memory. Not all CPUs are affected by Meltdown and Meltdown is being mitigated by operating system changes. Mounting a Meltdown attack via JavaScript running in WebKit requires first bypassing branch-based security checks, like in the case of a Spectre attack. Therefore, Spectre mitigations that fix the branch problem also prevent an attacker from using WebKit as the starting point for Meltdown.

This document explains how Spectre and Meltdown affect existing WebKit security mechanisms and what short-term and long-term fixes WebKit is deploying to provide protection against this new class of attacks. The first of these mitigations shipped on Jan 8, 2018:

• iOS 11.2.2.
• High Sierra 10.13.2 Supplemental Update. This reuses the 10.13.2 version number. You can check if your Safari and WebKit are patched by verifying the full version number in About Safari. The version number should be either 13604.4.7.1.6 or 13604.4.7.10.6.
• Safari 11.0.2 for El Capitan and Sierra. This reuses the 11.0.2 version number. Patched versions are 11604.4.7.1.6 (El Capitan) and 12604.4.7.1.6 (Sierra).

Spectre and Security Checks

Spectre means that branches are no longer sufficient for enforcing the security properties of read operations in WebKit. The most impacted subsystem is JavaScriptCore (WebKit’s JavaScript engine). Almost all bounds checks can be bypassed to read arbitrarily out-of-bounds. This could allow an attacker to read arbitrary memory. All type checks are also vulnerable. For example, if some type contains an integer at offset 8 while another type contains a pointer at offset 8, then an attacker could use Spectre to bypass the type check that is supposed to ensure that you can’t use the integer to craft an arbitrary pointer.

JavaScriptCore is meant to be a secure language virtual machine. It should be possible to load untrusted JavaScript or WebAssembly code into your process without the risk of your process’s memory being leaked to the JavaScript code except in cases where you explicitly export data to JavaScript via our C or Objective-C binding API. Spectre breaks this property of JavaScriptCore because untrusted JavaScript or WebAssembly now has a theoretical path to reading all of the host process’s address space.

DOM APIs and system APIs called by DOM APIs also use branches to enforce their security properties, and those are callable from JavaScript. Hence, Spectre is not just an attack on JavaScriptCore itself but also everything that is callable from JavaScript.

Reasoning About Spectre

To understand how Spectre works, it’s useful to think about how security-sensitive programming language operations (like any property access in JavaScript) get executed in JavaScriptCore on a modern processor. Most discussions about Spectre have involved bounds checks, so this section considers that case as well.

var tmp = intArray[index];

In this example, let’s assume that intArray is known to our JavaScript engine to be a reference to a Int32Array instance, but that we have not proved that index is in bounds of intArray.length. The compiler will have to emit a bounds check when it translates this high-level JavaScript operation into a lower-level form:

if (((unsigned) index) >= ((unsigned) intArray->length))
    fail;
int tmp = intArray->vector[index];

Compiling this on x86 CPUs results in the following instructions:

mov 0x10(%rsi), %rdx     ; %rsi has intArray. This loads
                         ; intArray->vector.
cmp 0x18(%rsi), %ecx     ; %ecx has the index. This compares
                         ; the index to intArray->length.
jae Lfail                ; Branch to Lfail if
                         ; index >= intArray->length according
                         ; to unsigned comparison.
mov (%rdx,%rcx,4), %ecx  ; Load intArray->vector[index].

Modern CPUs are able to execute the bounds check branch (jae) and the subsequent load (mov (%rdx,%rcx,4), %ecx) in parallel. This is possible because:

• Modern CPUs profile branches. In this case, they will observe that the branch always falls through. This is called branch prediction.
• Modern CPUs can roll back execution. The load after the branch can execute before the CPU verifies that the branch actually did fall through. If the branch turns out to be taken instead, the CPU can undo everything that happened between when the branch was encountered and when it finally got verified. This is called speculative execution.

Spectre is an attack that exploits information leaks from speculative execution. Consider this code:

var tmp = intArray[index];
otherArray[(tmp & 1) * 128];

The CPU has the ability to initiate loads from main memory into L1 (the CPU’s level 1 memory cache, which is the fastest and smallest) while executing speculatively. As a performance optimization, the CPU does not undo fetches into L1 when rolling back speculative execution. This leads to a timing-based information leak: in this code, whether the CPU loads otherArray[0] or otherArray[128] depends on tmp & 1, and it’s possible to later determine which the CPU loaded speculatively by timing the speed of access to otherArray[0] and otherArray[128].

The example so far involved controlling a bounds checking branch. This is a particularly effective Spectre attack because index behaves like a pointer that can be used to read ~16GB of memory above intArray->vector. But Spectre could theoretically involve any branch that enforces security properties, like the branches used for type checks in JavaScriptCore.

To summarize:

1. Spectre requires high fidelity timing so that the difference between L1 latency and main memory latency can be observed.
2. Spectre lets attackers control branches. Speculative execution executes branches according to past history, and the attacker can control this history. Therefore, the attacker controls what branches do during speculative execution.
3. Spectre is a race between the branch verifier and the initiation of the information-leaking load (what we wrote as otherArray[(tmp & 1) * 128] above). The attacker knows if they won the race (one of the two otherArray cache lines will be in L1), so the attack works so long as the attacker’s chance of winning is not zero.

Mitigating Spectre

WebKit’s response to Spectre is a two-tiered defense:

1. WebKit has disabled SharedArrayBuffer and reduced timer precision.
2. WebKit is transitioning to using branchless security checking in addition to branch-based security checking.

Some of these changes shipped in the Jan 8 updates and more such changes are continuing to land in WebKit. The remainder of this document covers our mitigations in detail.

Reducing Timer Precision

We are reducing timer precision in WebKit. These changes have landed in trunk as of r226495 and they shipped in the Jan 8 updates.

• Timer precision from performance.now and other sources is reduced to 1ms (r226495).
• We have disabled SharedArrayBuffer, since it can be used to create a high-resolution timer (r226386).

Our long-term plan is to make Spectre impossible even in the presence of high fidelity timing; further work is needed to re-enable this path.

Branchless Security Checks

Since learning about Spectre, we have been researching how to do security checks without relying on branches. We have begun making the transition to this new style of security checks and we shipped the first branchless checks in the Jan 8 updates.

Index Masking

The simplest example of a branchless security check is masking the index of an array access:

int tmp = intArray->vector[index & intArray->mask];

Modern CPUs do not speculate on bit masking. If the mask is picked to fit the array length, this mitigation ensures that even with Spectre, an attacker cannot read out-of-bounds of the array.

We have implemented index masking for:

1. Typed arrays (r226461),
2. WebAssembly memories (r226461, mostly via shared code with typed arrays),
3. Strings (r226068),
4. WTF::Vector (r226068), and
5. Plain JavaScript arrays (r225913).

Changes (1-4) shipped in the Jan 8 updates. (5) landed in WebKit but has not yet shipped.

Index masking is not yet a complete fix for out-of-bounds access. Our current index masking mitigations use a mask that is computed by rounding up the length to the next power of two (and subtracting one). This still allows out-of-bounds reads, just not to arbitrary memory.

Our current testing indicates that index masking has no measurable impact on the Speedometer and ARES-6 tests and an impact of less than 2.5% on the JetStream benchmark.

Pointer Poisoning

Index masking is easy to apply for array accesses, but many security check branches have to do with object type, not array bounds. Pointer poisoning is a technique that can be used to make any type check secure under Spectre by changing the shape of the object subject to the check.

Poisoning a pointer just means performing some reversible math on it that will make access attempts fail unless the pointer is unpoisoned. In WebKit, poisoning involves xoring a value that is sure to have at least one bit set in high positions so that accesses that do not unpoison are very likely to hit unmapped memory. WebKit picks poison values using a compile-time random number generator with lots of subtle rules, but to understand the approach, just consider 1 << 40 as a poison value. Adding one terabyte to a valid pointer is sure to result in an unmapped pointer in WebKit’s memory layout on macOS and iOS, and probably on other operating systems, too. Many possible poison values exist that would have this effect.

Poisoning becomes most powerful when each static declaration of a pointer field has a unique poison value, and the poison values differ in the high bits so that unpoisoning with the wrong value results in an unmapped pointer.

As an example of how to apply pointer poisoning as a branchless type check, consider some class Foo that belongs to a hierarchy of classes that participate in dynamic downcasts based on some checks:

class Foo : public Base {
public:
    ...
private:
    int m_x;
    Bar* m_y;
};

In order to make this class’s type checks sound under Spectre, we can simply move Foo’s fields out into a data struct pointed to by a uniquely poisoned pointer:

class Foo : public Base {
public:
    ....
private:
    struct Data {
        int x;
        Bar* y;
    };
    ConstExprPoisoned<FooDataKey, Data> m_data;
};

Where FooDataKey is a key unique to Foo, based on which ConstExprPoisoned<> will compute a random poison value at compile time. If all classes in this hierarchy use a pointer poisoned indirection to protect their fields then this suffices as a branchless type check for all accesses to these types. In addition to being a great Spectre mitigation, this is also a useful remote code execution mitigation, since it makes it harder to do any kind of type confusion.

Pointer poisoning sometimes does not require any extra indirections. JavaScriptCore has tons of data structures that roughly fit this pattern:

struct Thingy {
    Type type;
    void* data; // The shape of this depends on `type`.
};

Any such data structure’s type checks can be made branchless by poisoning the data pointer according to a poison value that depends on type.

We have begun converting WebKit’s object models to use pointer poisoning (r225363, rr225437, r225632, r225659, r225697, r225857, r226015, r226247, r226344, r226485, r226530), and some of the initial pointer poisoning work is shipping in the Jan 8 updates (specifically, r225363–r225857). So far, we have not observed any performance regressions from using pointer poisoning.

Mitigating Meltdown

Meltdown allows userland code to read kernel memory. WebKit is indirectly affected by Meltdown because a Meltdown attack could be initiated using any kind of code execution, including JavaScript. However, the memory accesses used to perform Meltdown would be a violation of WebKit’s security model. Therefore, JavaScript-based Meltdown attacks must first get around WebKit’s security checks such as by using a Spectre attack.

If Meltdown has been mitigated by operating system changes, then even if WebKit lacked any Spectre mitigations, it would not be possible to mount a Meltdown attack via WebKit. Any future Spectre mitigations will make it even less likely that WebKit could be used for a Meltdown attack, since the Spectre stage of that attack will be harder.

Recommendations For App Developers

Spectre means that secrets in the same address space as untrusted JavaScript are more vulnerable than ever before. Based on this, we recommend:

• Switch to the Modern WebKit API if you have not done so already. This protects your app by running untrusted JavaScript in another process.
• Avoid exposing sources of high-precision timing to untrusted JavaScript or WebAssembly.

Conclusion

Spectre and Meltdown are a new class of security issues that apply to modern processors and the software that runs on them. WebKit is affected by both issues because WebKit allows untrusted code to run on users’ processors. In response to these new issues, we have implemented mitigations to defend against Spectre (and Meltdown attacks launched using Spectre via the browser). The first of these mitigations have shipped in the Jan 8 updates (iOS 11.2.2, High Sierra 10.13.2 supplemental update, and Safari 11.0.2 reissue). Stay tuned for more WebKit Spectre fixes!

You’ve launched your online community. You’ve got hundreds, maybe thousands, of active members.

But there is a problem; you’re not sure what you want them to do.

You’re not alone, this happens to the majority of companies we’ve worked with. Many have invested a lot of time and resources to get members to participate without ever answering the fundamental question; ‘what do we need our members to do?’

This usually leads to asking the wrong members to do the wrong things. Fortunately, it’s a very fixable problem.

In this post, I want to take you through a process we go through with clients. This highlights the most valuable things a member can do, the challenges you will need to overcome, and a framework you can use to move forward.

Only A Small Percentage Of Community Contributions Matter

Only a few contributions to your community are valuable. These are the contributions which drive the results you want. They also tend to bring in other members, set the tone for the community, and carve out a unique identity.

You can have a lot of people talking about a lot of things in a place you control (and pay for), but this doesn’t mean it’s valuable. This is like owning a popular bar where people bring their own drinks. Your members get the social benefits while you pay for the overheads.

Your mission is to get every member making their best possible contribution to the community. These are valuable contributions which help you achieve your goal.

What Should Your Active Members Do?

Let’s focus on active members here (we will cover lurkers another time).

Begin by working backward from the result you want. Use this table below if it helps.

This isn’t a definitive list. You should notice however that only a very narrow number of contributions are valuable from active members.

If you want to avoid building another opinion-sharing community, you need to be clear what you want your contributors (usually up to 10% of your membership) to do first.

Select the contributions that most closely match up your goal. Be very clear and specific in the contributions you want members to make.

e.g. ‘members writing detailed blog posts’ as opposed to ‘members sharing good advice’

By the end of this stage you should have identified the contributions you need to achieve your goal.

Great Examples Of Valuable Contributions

The best communities are defined by the great contributions members make.
If you need some examples, here are a few:

• The Spotify Rock Star program has a few hundred people who contribute thousands of great quality solutions every year. These great contributions (quick, personalized, solutions) bring in hundreds of thousands of members and reduce support costs for 6.4m+ members.
• ProjectManagement.com has the smartest people in Project Management sharing detailed articles and resources. These templates and resources saves thousands of people spending days, even weeks, of their lives creating their own resources to do their work. They also serve as a premium feature of the community.
• The Adobe forums has thousands of members sharing their best tips to use the products better. These tips aren’t just targeted at the elite experts, they’re targeted at the far bigger audience of newcomers. This reduces churn, increases loyalty, and improves search traffic.
• Goodreads has members publishing dozens of independent, quality, reviews every minute. This provides Amazon with a treasure trove of information and increases sales.

Each of the communities above are crystal clear in what they wanted members to do. They orientate their activities around these goals. They didn’t hope they would happen by chance if they got enough activity, they proactively drove those behaviors first.

Why Your Members Aren’t Making Great Contributions

Most people, perhaps you too, are making the same mistake. You’re asking members to make contributions they don’t have the skill, time, and motivation to create.

Once you’ve identified the contributions you want, it’s tempting to start blasting messages out to members asking them to make those contributions.

The problem is different kinds of contributions require different attributes from members. A newcomer to the field can hardly be expected to share expert advice.

…But that’s exactly what happens in many communities(!)

These attributes typically fall within three categories;

1) Skills/experience. Great contributions like those above require a significant experience or an acquired skill. If a member doesn’t feel they have a unique skill or experience to share with the community, they won’t participate.

2) Motivation. Motivating refers to deviance from normal behavior. This means getting members to proactively do something they wouldn’t usually do (and don’t see peers doing).

3) Time. This refers to taking an hour or more to contribute the contribution. If you’re writing a review, this doesn’t matter, but if you’re about to share a detailed resource or host an AMA, the member needs the time to create that post.

You can influence each of these a little. You can train members, reduce the time it makes to make a great contribution (e.g. pre-set resources/templates), and deploy motivational messages. This is good practice too. But you’re still going to be working within these relatively fixed restraints. You can’t get members to do things they aren’t able (or willing) to do.

So, what’s the solution?

Going Beyond An Opinion-Sharing Community

You need to match the kind of contributions you want to the members who have the skill/experience, motivation, and time to do those things.

This means identifying members who have the ability to make these contributions and spending more time on them. You can use different systems for each of these.

1) Skill/Expertise. Tag members who demonstrate expertise in a particular niche. You and your volunteers can use admin notes on profiles, create customer badges, or keep a separate list on excel/google sheets (the latter is easiest). Whenever a member makes a great contribution on a topic, tag the contribution to member’s profile/contribution.

2) Motivation. This is harder to fathom. One simple method is to look either at members who create the most posts, those who create deviant posts (e.g. publishing something different or unique), or use your own subjective observations. Listing members by the number of posts they have made is easiest. Set a mark, usually 5+ contributions in the past month.

3) Time. Create a list of members who have either spent the most time on the site or read the most posts within the previous 60 days. You can do this by either listing members by time spent or the site/posts read. You can list members from native features or, if you’re pulling data from the server logs, you can run a simple query below.

(We use Discourse with the Data Explorer Plugin).

This provides a list of members who have read more than 50+ posts within the past 60 days (you can change these variables to suit you).

You can build increasingly complex and automated systems to add people to the right list. The key principle is you should now be able to divide your regular members into active groups based upon the table below:

(yes, this list is quite subjective)

Now you place many of your active members into the categories above (feel free to add your own) and pursue those on lists which lead to the contributions you need to achieve your goals.

• If someone appears on all three lists, you want to invite them to share a detailed resource/template based upon their expertise. Highlight the kind of resources you need, emphasize the status of those resources, identify similar resources elsewhere for them.
• If someone appears on experience and motivation, you want to see if they can share their best tips or solutions on a semi-regular basis. Highlight the tips required, the impact they have, and make a big deal out of great tips shared.
• If someone appears on time and motivation, guide them to volunteer or leadership roles within the community (hosting interviews, welcoming members, moderating areas of the site etc…).
• If someone appears just on motivation, ask them to highlight or vote on the kind of content or material they would love to see in the community. Then feed this back to members creating tips/resources.
• If someone appears just on one list (e.g. experience), you might want them to share reviews or help connect members where possible. etc…

The more resources you have, the more lists you can pursue.

You can begin with just a single list if you like (perhaps resources/templates), find people who fall into that category, and see if you can start adding some tremendous templates and resources to your community. This is terrific for lead generation.

Your goal by the end of this is to make sure every member is making their best possible contribution to the community.

Good luck.

Every Event is a daft little WebExtension I wrote a while ago to try and capture the events that WebExtensions APIs fires. It tries to listen to every possible event that is generated. I've found this pretty useful in past for asking questions like "What tab events fire when I move tabs between windows?" or "What events fire when I bookmark something?".

To use Every Event, install it from addons.mozilla.org. To open, click the alarm icon on the menu bar.

If you turn on every event for everything, you get an awful lot of traffic to the console. You might want to limit that down. So to test what happens when you bookmark something, click "All off", then click "bookmarks". Then click "Turn on". Then open the "Browser Console".

Each time you bookmark something, you'll see the event and the contents of the API as shown below:

That's also thanks to the Firefox Developer Tools which are great for inspecting objects.

But there's one other advantage to having Every Event around. Because it requests every single permission, it has access to every API. So that means if you go to about:debugging and then click on Debug for Every Event, you can play around with all the APIs and get nice autocomplete:

All you have to do is enter "browser." at the browser console and there's all the WebExtension APIs autocompletable.

Let's add in our own custom handler for browser.bookmarks.onRemoved.addListener and see what happens when I remove a bookmark...

Finally, I keep a checkout of Every Event near by on all my machines. All I have to do is enter the Every Event directory and start web-ext:

web-ext run --firefox /Applications/FirefoxNightly.app/Contents/MacOS/firefox --verbose --start-url about:debugging

That's aliased to a nice short command on my Mac and gives me a clean profile with the relevant console just one click away...

Update: see also shell WebExtension project by Martin Giger which has some more sophisticated content script support.

If you use two wheels for transport, we suggest carrying your everyday gear not on your body, but on your bike. The best option for most people is usually a pannier, a bag that attaches to your bike’s rear rack and won’t make your bike hard to steer. After spending three years testing dozens of panniers, we’ve chosen eight that’ll be great for daily duty no matter what you’re toting.

John Kijinski, Inside Higher Ed, Jan 12, 2018

---

The comment thread is far and away the best part of this article. Working without data or evidence, the author argues that in-class learning is more valuable than experiential learning. "The most valuable thing we can teach students is the ability to think through, with patient focus, demanding intellectual challenges." But even the examples provided - as the commenters argue - have real-life experiences that are every bit as demanding as the in-class alternative. 

[Link] [Comment]

Isabel Fattal, The Atlantic, Jan 12, 2018

---

With the recent news that Disney will acquire the lion king's share of American cultural assets it becomes relevant to ask about the messages it uses this content to send. History does not reassure us. From the ideology of Donald Duck to the sexism of Disney princesses to their issues with dark skin, Disney has been sending messages of dubious ethical value to children for decades. This article examines another aspect: why Disney villians all have 'foreign' accents. Note that "stereotyped uses of language aren’t an industry-wide norm; they said that networks such as PBS make a concerted effort to prioritize racial and ethnic diversity and accuracy." 

[Link] [Comment]

Wikipedia aims to be verifiable. Every statement of fact should be supported by a reliable source that the reader can check. Citations in Wikipedia typically refer to online documents accessible at URLs. But with the advent of standard web annotation we can do better. We can add citations to Wikipedia that refer precisely to statements that support Wikipedia articles.

According to Wikipedia’s policy on citing sources:

Wikipedia’s Verifiability policy requires inline citations for any material challenged or likely to be challenged, and for all quotations, anywhere in article space.

Last night, reading https://en.wikipedia.org/wiki/Tubbs_Fire, I noticed this unsourced quote:

Sonoma County has four “historic wildfire corridors,” including the Hanly Fire area.

I searched for the source of that quotation, found it in a Press Democrat story, annotated the quote, and captured a Hypothesis direct link to the annotation. In this screenshot, I’ve clicked the annotation’s share icon, and then clicked the clipboard icon to copy the direct link to the clipboard. The direct link encapsulates the URL of the story, plus the information needed to locate the quotation within the story.

Given such a direct link, it’s straightforward to use it in a Wikipedia citation. Back in the Wikipedia page I clicked the Edit link, switched to the visual editor, set my cursor at the end of the unsourced quote, and clicked the visual editor’s Cite button to invoke this panel:

There I selected the news template, and filled in the form in the usual way, providing the title of the news story, its date, its author, the name of the publication, and the date on which I accessed the story. There was just one crucial difference. Instead of using the Press Democrat URL, I used the Hypothesis direct link.

And voilà! There’s my citation, number 69, nestled among all the others.

Citation, as we’ve known it, begs to be reinvented in the era of standard web annotation. When I point you to a document in support of a claim, I’m often thinking of a particular statement in that document. But the burden is on you to find that statement in the document to which my citation links. And when you do, you may not be certain you’ve found the statement implied by my link. When I use a direct link, I relieve you of that burden and uncertainty. You land in the cited document at the right place, with the supporting statement highlighted. And if it’s helpful we can discuss the supporting statement in that context.

I can envision all sorts of ways to turbocharge Wikipedia’s workflow with annotation-powered tools. But no extra tooling is required to use Hypothesis and Wikipedia in the way I’ve shown here. If you find an unsourced quote in Wikipedia, just annotate it in its source context, capture the direct link, and use it in the regular citation workflow. For a reader who clicks through Wikipedia citations to check original sources, this method yields a nice improvement over the status quo.

Mark Richard Johnson, Robert Mejia, Aleena Chia, Ian Gregory Brooks, Journal of Virtual Worlds Research, Jan 12, 2018

---

I thoroughly enjoyed this special issue of the Journal of Virtual Worlds Research (JVWR) focusing on the massively multiplayer online games (MMOs) Eve Online. The game is set in space and is generally a free-for-all of space mining, pirates and corporations. The play and the politics become complex, as documented in Making Science Fiction Real: Neoliberalism, Real-Life and Esports in Eve Online by Mark Richard Johnson and Robert Mejia. Similar themes are explored in Scaling Technoliberalism for Massively Multiplayer Online Games, by Aleena Chia. Meanwhile, Ian Gregory Brooks asks Is Betrayal in EVE Online Unethical? Answer: yes. 

[Link] [Comment]

I confess that I am sometimes whiplashed by the swing from high to low in the articles I read in my...

Artificial Intelligence #AI Machine Learning #ML Augmented Virtual Reality #AR #VR #MR Alexa Voice Blockchain Cryptocurrency Bitcoin Ethereum #5G #Asbestos

This is just a test. Nothing to see here. Move along.

Samsung Flip (Photo Samsung)

Im Dezember hat Samsung sein neues Flip schon mal der Presse unter NDA vorgestellt. Das ist ein elektronisches Flipchart. Der Pitch geht ungefähr so: "Nie ist Papier da und die Stifte sind dauernd ausgetrocknet." Auf dem Flip kann man auch mit einem Löffel schreiben und da es scrollt, ist auch nie das Papier alle. Außerdem kann man es per NFC mit einem Galaxy pairen und dann den Bildschirminhalt drauf projizieren. Das Flip ist drehbar und kann auch Querformat. Es ist jedoch nicht vernetzt und kann keine zwei Lokationen zusammenbringen, wie das Surface Hub oder Cisco Spark Board vormachen.

Ich habe einen Usecase, den das Gerät nicht abbildet. Ein Blatt Papier vom Flipchart abreissen und auf den Tisch legen und darauf die Besprechung skizzieren. Dann einmal fotografieren und in Stücke zerlegen, die die Teammitglieder dann als Aufgaben bis zum nächsten Meeting mitnehmen. Alles am Stehtisch und zweimal am Tag. Ich organisiere für viele überraschend analog.

From The Guardian:

Past Planning Director Ray Spaxman circulated this comment on Sunday:

It is disturbing to be living at a time when bad manners are being condoned by the community. Obviously dreadful behaviour, as displayed continuously by that powerful man to the south of us, seems to be encouraging the “bad mannered” to expand that behaviour into all walks of life.

It seems that some rich and powerful, and-or big and strong people, are able not only to display bad manners, they seem also to obtain the approval of the various authorities that have evolved over time in our communities to prevent the worst “bad manners” from disrupting our sense of comfort in our neighbourhoods.  

I have also noted another trend, which I know some of you have noticed too, and that is the increasing bad manners that can occur in development and especially in architecture. Bad-mannered architecture has been an issue for centuries but we seem to be going through a phase when bad manners is condoned for the sake of money, international recognition or simply absence of mind.

The latest example is the proposed residential tower at 1500 Georgia Street.The building rendering below is taken from the current application going before Council next week.

.

Price Tags: The counter response to Ray’s argument has been that ‘good-mannered’ architecture has produced bland, albeit respectful, architecture and that occasionally something more adventuresome and provocative is needed to add dynamism to the urban landscape.  Is Vancouver open to new ideas and the work of the avant-garde, or does it remain good-mannered and dull?

Or are there other considerations and points of view?

Cast: roland

Tags: bicycling, bicyclingfromwork, vancouver and rainy

Darren Barefoot @dbarefoot
First blog post in about 18 months, kind of a review but mostly about a conspicuous absence in a great movie. darrenbarefoot.com/archives/2018/…

Jim Pick @jimpick
NHK visited Vancouver and did a show about the Campagnolo upstairs bar youtu.be/DWMYov55d8A

Shortly after HP and Asus revealed their ARM-based Windows 10 laptops at Qualcomm’s Snapdragon Tech Summit, Lenovo has now unveiled its own always-connected 2-in-1, the Miix 630.

The Miix 630 runs on Qualcomm’s 835 ARM-based chipset rather than Intel’s dominant x86 processor, allowing for advantages including the use of Qualcomm’s LTE modem, a lightweight design and room for a large battery.

Lenovo is using those advantages to offer an estimated 20 hours of battery life for its new detachable 2-in-1, which it says is 15.6mm thick and weighs 2.93 lbs, keyboard included.

The fanless device also features a 12.3-inch WUXGA+ screen, 4GB or 8GB of RAM, and storage options up to 256GB. As for ports, there’s one USB-C, and one microSD slot.

Like the Asus NovaGo and HP Envy x2, the Miix 630 runs Windows 10 S — Microsoft’s limited education-focused OS variant that only allows users to run Windows apps — but can be updated free of charge to Windows 10 Pro, where it will run full desktop apps using Microsoft’s emulator. It’s still unclear how well that will work, however, as so far press have only been able to use the device running Windows 10 S.

The Miix 630 comes with a keyboard and Lenovo digital pen and starts at $799.99 USD. Lenovo says it’s expected to be available beginning in the second quarter of 2018 online and through select local carriers.

MobileSyrup has reached out to Lenovo for Canadian pricing and availability.

Source: Lenovo

The post Lenovo reveals ARM-based, always-connected Miix 630 2-in-1 appeared first on MobileSyrup.

Joining Apple, Samsung and Google (sort of) in the truly wireless earbud market, Sony is back this year with the new WF-SP700N earbuds, the successor to last year’s relatively well-received WF-1000X.

The headphones feature digital noise cancellation and are IPX4-rated for sweat and water resistance.

Sony says the headphones feature strong bass performance and battery life that measures in at about three hours, putting the wireless earbud in-line with competing products like the AirPods and Pixel Buds.

The earbuds’ case is capable of two additional charges, lasting a total of nine hours. The WF-SP700N are set to release this spring for $179 USD (about $222 CAD).

Sonys says that Google Assistant integration is set to come to the WF-SP700N earbuds eventually, but hasn’t committed to a specific release date.

Along with its new wireless earbuds, Sony is also launching new WI-SP600N noise cancelling neckbuds that are IPX4 splash-proof. Sony says the headphone’s battery life measures in at six hours. The WI-SP600N earbuds are set to retail for $149 USD (about $185 CAD).

Finally, Sony also showed off the rather strange looking WI-SP500 headphones, which offer eight hours of battery life and IPX4 water resistance. The wired headphones don’t feature noise cancellation, but come in at a more reasonably priced $79 USD (approximately $98 CAD).

All three of Sony’s 2018 headphone offerings are capable of NFC pairing, which is great if you’re an Android user. What’s strange though, is Sony’s insistence on sticking to a cumbersome, multi-letter/number naming convention for almost all of its headphones.

We’ve reached out to Sony for specific Canadian pricing information regarding all three pairs of headphones.

The post Sony shows off new truly wireless, noise cancelling earbuds appeared first on MobileSyrup.

You’ve heard the adage “It’s all 1s and 0s”, but that’s not a figure of speech: the transistor, the fundamental building block of computers, is simply a switch that is either on (“1”) or off (“0”). It turns out, though, as Chris Dixon chronicled in a wonderful essay entitled How Aristotle Created the Computer, that 1s and 0s, through the combination of mathematical logic and transistors, are all you need:

The history of computers is often told as a history of objects, from the abacus to the Babbage engine up through the code-breaking machines of World War II. In fact, it is better understood as a history of ideas, mainly ideas that emerged from mathematical logic, an obscure and cult-like discipline that first developed in the 19th century.

Dixon’s essay — which I’ve linked to previously — is well worth a read, but the relevant point for this article is perhaps a surprising one: computers are really stupid; what makes them useful is that they are stupid really quickly.

The Problem with Processor Vulnerabilities

Last week the technology world was shaken by the disclosure of two vulnerabilities in modern processors: Meltdown and Spectre. The announcement was a bit haphazard, thanks to the fact that the disclosure date was moved up by a week due to widespread speculation about the nature of the vulnerability (probably driven by updates to the Linux kernel), but also because Meltdown and Spectre are similar in some respects, but different in others.

Start with the similarities: the outcome for both vulnerabilities is the same — a non-privileged user can access information on the computer they should not be able to, like secret keys or passwords or any other type of data owned by other users. This is a particularly big problem for cloud services like AWS, where multiple “tenants” use the same physical hardware:

This multi-tenant architecture is achieved through the use of virtual machines: there is specialized software that runs on a single physical computer that allows each individual user to operate as if they have their own computer, when in fact they are sharing. This is a win-win: single-user computers sit idle the vast majority of the time (they are stupid really quickly), but if multiple users can use one computer then the hardware can be utilized far more efficiently. And, in the case of cloud services, that same concept can be scaled up to millions of physical computers sharing even more fundamental infrastructure like cooling, networking, administration, etc.

The entire edifice, though, is predicated on a fundamental assumption: that users in one virtual machine cannot access data from another. That assumption, by extension, relies on trust in the integrity of the virtual machine software, which relies on trust in the integrity of the underlying operating system, which ultimately relies on trust in the processor at the heart of a server. From the Meltdown white paper (emphasis mine):

To load data from the main memory into a register, the data in the main memory is referenced using a virtual address. In parallel to translating a virtual address into a physical address, the CPU also checks the permission bits of the virtual address, i.e., whether this virtual address is user accessible or only accessible by the kernel. As already discussed in Section 2.2, this hardware-based isolation through a permission bit is considered secure and recommended by the hardware vendors. Hence, modern operating systems always map the entire kernel into the virtual address space of every user process. As a consequence, all kernel addresses lead to a valid physical address when translating them, and the CPU can access the content of such addresses. The only difference to accessing a user space address is that the CPU raises an exception as the current permission level does not allow to access such an address. Hence, the user space cannot simply read the contents of such an address.

The kernel is the core part of the operating system that should be inaccessible by normal users; it has its own memory to store not only core system data but also data from all of the users (for example, when it has to be written to or read from permanent storage). Even here, though, the system relies on virtualization — that memory is the same physical memory users utilize for their applications. It is up to the CPU to keep track of what parts of memory belong to whom, and this is where the vulnerabilities come in.

Speculative Execution

I just referenced three critical parts of a computer: the processor, memory, and permanent storage. In fact, the architecture for storing data is even more complex than that:

• Registers are the fastest form of memory, accessible every single clock cycle (that is, a 2.0 GHz processor can access registers two billion times a second). They are also the smallest, usually only containing the inputs and outputs for the current calculation.
• There are then various levels of cache (L1, L2, etc.) that are increasingly slower and, on the flipside, increasingly larger and less expensive. This cache is located in a hierarchy: data that is needed immediately will be moved from the registers to L1 cache, for example; slightly less necessary data will be in L2, then L3, etc.
• The next major part of the memory hierarchy is main memory, that is system RAM. While the amount of cache is dependent on the processor model, the amount of memory is up to the overall system builder. This memory is massively slower than cache, but it is also massively larger and far less expensive.
• The last part of the memory hierarchy, at least on a single computer, is permanent storage — the hard drive. Solid-state drives (SSDs) have made a huge difference in speed here, but even then permanent memory is massively slower than main memory, with the same tradeoffs: you can have a lot more of it at a much lower price.
• While not part of the traditional memory hierarchy, cloud applications often have permanent memory on a separate physical server on the same network; the usual tradeoffs apply — very slow access in exchange for other benefits, in this case keeping data separate from its application.

To be sure, “very slow” is all relative — we are talking about nanoseconds here. This post by Jeff Atwood puts it in human terms:

That infinite space “between” what we humans feel as time is where computers spend all their time. It’s an entirely different timescale. The book Systems Performance: Enterprise and the Cloud has a great table that illustrates just how enormous these time differentials are. Just translate computer time into arbitrary seconds:

1 CPU cycle	0.3 ns	1 s
Level 1 cache access	0.9 ns	3 s
Level 2 cache access	2.8 ns	9 s
Level 3 cache access	12.9 ns	43 s
Main memory access	120 ns	6 min
Solid-state disk I/O	50-150 μs	2-6 days
Rotational disk I/O	1-10 ms	1-12 months
Internet: SF to NYC	40 ms	4 years
Internet: SF to UK	81 ms	8 years
Internet: SF to Australia	183 ms	19 years
OS virtualization reboot	4 s	423 years
SCSI command time-out	30 s	3000 years
Hardware virtualization reboot	40 s	4000 years
Physical system reboot	5 m	32 millenia

[…]

The late, great Jim Gray…also had an interesting way of explaining this. If the CPU registers are how long it takes you to fetch data from your brain, then going to disk is the equivalent of fetching data from Pluto.

Gray presented this slide while at Microsoft, to give context to that that “Olympia, Washington” reference. Let me extend his analogy:

Suppose you were a college student interning for the summer at Microsoft in Redmond, and you were packing clothes at home in Olympia. Now Seattle summers can be quite finicky — it could be blustery and rainy, or hot and sunny. It’s often hard to know what the weather will be like until the morning of. To that end, the prudent course of action would not be to pack only one set of clothes, but rather to pack clothes for either possibility. After all, it is far faster to change clothes from a suitcase than it is to drive home to Olympia every time the weather changes.

This is where the analogy starts to fall apart: what modern processors do to alleviate the time it takes to fetch data is not only fetch more data than they might need, but actually do calculations on that data ahead-of-time. This is known as speculative execution, and it is the heart of these vulnerabilities. To put this analogy in algorithmic form:

• Check the weather (execute multiple sub-processes that trigger sensors, relay data, etc.)
  • If the weather is sunny, wear shorts-and-t-shirt
  • Else wear jeans-and-sweatshirt

Remember, computers are stupid, but they are stupid fast: executing “wear shorts-and-t-shirt” or “wear jeans-and-sweatshirt” takes nanoseconds — what takes time is waiting for the weather observation. So to save time the processor will get you dressed before it knows the weather, usually based on history — what was the weather the last several days? That means you can decide on footwear, accessories, etc., all while waiting for the weather observation. That’s the other thing about processors: they can do a lot of things at the same time. To that end the fastest possible way to get something done is to guess what the final outcome will be and backtrack if necessary.

Meltdown

Now, imagine the algorithm was changed to the following:

• Check your manager’s calendar to see if they will be in the office
  • If they will be in the office, wear slacks and collared-shirt
  • If they will not be in the office, wear shorts-and-t-shirt

There’s just one problem: you’re not supposed to have access to your manager’s calendar. Keep in mind that computers are stupid: the processor doesn’t know this implicitly, it has to actually check if you have access. So in practice this algorithm is more like this:

• Check your manager’s calendar to see if they will be in the office
  • Check if this intern has access to their manager’s calendar
    • If the intern has access, access the calendar
      • If they will be in the office, wear slacks and collared-shirt
      • If they will not be in the office, wear shorts-and-t-shirt
    • If the intern does not have access, stop getting dressed

Remember, though, computers are very good at doing lots of things at once, and not very good at looking up data; in this case the processor will, under certain conditions, look at the manager’s calendar and decide what to wear before it knows whether or not it should look at the calendar. If it later realizes it shouldn’t have access to the calendar it will undo everything, but the clothes might end up slightly disheveled, which means you might be able to back out the answer you weren’t supposed to know.

I already said that the analogy was falling apart; it is now in complete tatters but this, in broad-strokes, is Meltdown: the processor will speculatively fetch and execute privileged data before it knows if it should or not; that process, though, leaves traces in cache, and those traces can be captured by a non-privileged user.

Explaining Spectre

Spectre is even more devious, but harder to pull off: remember, multiple users are using the same processor — roommates, if you will. Suppose I pack my suitcase the same as you, and then I “train” the processor to always expect sunny days (perhaps I run a simulation program and make every day sunny). The processor will start choosing shorts-and-t-shirt ahead of time. Then, when you wake up, the processor will have already chosen shorts-and-t-shirt; if it is actually rainy, it will put the shorts-and-t-shirt back, but ever-so-slightly disheveled.

This analogy has gone from tatters to total disintegration — it really doesn’t work here. Your data isn’t simply retrieved from main memory speculatively, it is momentarily parked in cache while the processor follows the wrong branch; it is quickly removed once the processor fixes it error, but I can still figure out what data was there — which means I’ve now stolen your data.

Meltdown is easier to explain because — Intel’s protestation to the contrary (Meltdown also affects Apple’s processors) — it is due to a design flaw. The processor is responsible for checking if data can be accessed, and to check too slowly, such that the data can be stolen, is a bug. That is also why Meltdown can be worked around in software (basically, there will be an extra step checking permissions before using the data, which is why the patch causes a performance hit).

Spectre is something else entirely: this is the processor acting as designed. Computers do basic calculations unfathomably quickly, but take forever to get the data to make those calculations: therefore doing calculations without waiting for bottlenecks, based on best guesses, is the best possible way to leverage this fundamental imbalance. Most of the time you will get results far more quickly, and if you guess wrong you are no slower than you would have been had you done everything in order.

This, too, is why Spectre affects all processors: the speed gains from leveraging modern processors’ parallelism and execution speed are so massive that speculative execution is an obvious choice; that the branch predictor might be trained by another user such that cache changes could be tracked simply didn’t occur to anyone until the last year (that we know of).

And, by extension, Spectre can’t be fixed by software: specific implementations can be blocked, but the vulnerability is built-in. New processors will need to be designed, but the billions of processors in use aren’t going anywhere. We’re going to have to muddle through.

Spectre and the State of Technology

I ended 2017 without my customary “State of Technology” post, and just as well: Spectre is a far better representation than anything I might have written. Faced with a fundamental imbalance (data fetch slowness versus execution speed), processor engineers devised an ingenious system optimized for performance, but having failed to envision the possibility of bad actors abusing the system, everyone was left vulnerable.

The analogy is obvious: faced with a fundamental imbalance (the difficulty of gaining and retaining users versus the ease of rapid iteration and optimization), Internet companies devised ingenious systems optimized for engagement, but having failed to envision the possibility of bad actors abusing the system, everyone was left vulnerable.

Spectre, though, helps illustrate why these issues are so vexing:

• I don’t believe anyone intended to create this vulnerability
• The vulnerability might be worth it — the gains from faster processors have been absolutely massive!
• Regardless, decisions made in the past are in the past: the best we can do is muddle through

So it is with the effects of Facebook, Google/YouTube, etc., and the Internet broadly. Power comes from giving people what they want — hardly a bad motivation! — and the benefits still may — probably? — outweigh the downsides. Regardless, our only choice is to move forward.

Vicki Huntington needs no introduction to the people living in Delta. Ms. Huntington was the former MLA for Delta South and has an outstanding  background of public service.  Among her many accomplishments she has been a band manager for the Gitanmaax First Nation in Hazelton, worked with the RCMP in their security services, and consulted with  ministers of the Crown in Ottawa. She also served five terms as a Councillor in the City of Delta and two terms as the MLA.  She believes strongly in maintaining farmland for future generations and has been recognized for her strong commitment to farming and nature.

Vicki did not run in the last Provincial election for her independent seat~had she run as an independent, she would have been part of the balance of power in the Provincial government coalition. Instead, Delta Councillor Ian Paton of the Liberals won that seat, and currently double dips between sitting on Delta Council (he is paid $62,000 a year plus his expenses) as well as sitting as an MLA where he makes an additional $106,000 plus. Mr. Paton was named newsmaker of the year  by the Delta Optimist, not for double dipping and denying Delta of a more independent voice on Council, but  because he became  a member of the Provincial legislature.  Mr. Paton claims to want the farmer’s best interest but has been unwavering in the support of a multi-billion dollar ten lane bridge which will industrialize the Fraser River, create congestion on either side of the bridge, and purportedly bring more industry to Delta.

What a shame that the Delta Optimist did not recognize Ms Huntington who was the first independent MLA in over sixty years, and the first to be re-elected. However Ms. Huntington has been appointed to the new committee reviewing the Agricultural Land Commission and Agricultural Land Reserve along with eight other members. Their mission is to provide  “strategic advice, policy guidance and recommendations on how to help revitalize the Agricultural Land Reserve and the Agricultural Land Commission to ensure the provincial goals of preserving agricultural land and encouraging farming and ranching continue to be a priority.”

There is no doubt that the Agricultural Land Reserve is essential to the health and food security of British Columbia and must be maintained for future generations. Price Tags Vancouver has already written about the City of Delta carving out ten acres of farmland for a “truck staging area” for port bound trucks, and how the Port of Vancouver has another  81 acres of farmland in Richmond to add to their 1,457 hectares currently in “industrial use”. It’s a huge problem~should the Port be allowed to take the most arable farmland in Canada to use for truck and container parking and portage? How can farmers be compensated and continue farming when they can garner economic windfalls from development through port expansion or pseudo “farm estates” to well-heeled buyers?

This new Agricultural Land Commission review  committee will seek opinions and feedback and hold meetings with  farming and ranching communities. Recommendations could include changes to the way the Agricultural Land Reserve and the Agricultural Land Commission is set up, regulated and administered. This review is badly needed to ensure that agricultural land is reserved for future populations, and to stop speculators buying up farmland for other purposes. The current MLA for Delta South Mr. Paton is already naysaying the committee appointments,  suggesting that maintaining land in agricultural use restrains the rights of farmers to get extra income from their land. But farmers and speculators did buy that agricultural land  ostensibly for agricultural purposes, and for the future of the region, we must ensure that this agricultural land, the very best in Canada, remains for future generations.

Gwo-Jen Hwang, Nien-Ting Tu, Xiao-Ming Wang, Educational Technology & Society, Jan 11, 2018

---

A couple of things are going on in this article. First is the design of the interactive e-book itself, which serves as an illustration of this approach in learning technology. Second is the assessment of the "quasi-experimental design method" employed in the design of the interactive e-Books. The result is assessed for learning outcomes, student satisfaction, cognitive load, and various other factors. It's a good read, detailed and informative.

[Link] [Comment]

Alex Young Pedersen, Rikke Toft Nørgaard, Christian Köppe, Educational Technology & Society, Jan 11, 2018

---

This is an erudite and intelligent paper combining three major threads. First, the idea of digital citizenship as an extension of T.H. Marshall's influential conception of social, economic and political rights and responsibilties. Second is the elucidation of hybrid education based on the concepts of 'becoming', which leads to plurality ("nobody is ever the same as anyone else who ever lived, lives or will live.”), and 'belonging', as seen in the concept of community ("this reconsideration of digital citizenship takes aim at the philosophical and ethical foundations for a reconfiguration of education"). And third is the mechanism of patterns and pattern languages, draw brom Alexander's ideas of patterns as bound to the problem, linked to the community, and connected to other patterns. The outcome is an EduPLoP(Pattern Languages of Programs) workshop, which is described and assessed in this paper.

[Link] [Comment]

“In 1964, I was a little girl sitting on the linoleum floor of my mother’s house in Milwaukee...

For once, I’m not deleting anything. But, I’ve been struck by how

a) bad algorithmic news feeds are at actually getting what I want and need, and

b) how horribly distracting and time-sucking they are.

Companies – and we’re well past the rubicon of DIY internet hippie utopia – it’s companies all the way down now – have no reason to make their algorithms work better for me (or other humans). Their algorithms weren’t designed for that – their only reason for existing is to generate advertising revenue for the company, and to maximize that at all costs.

Cool. But I don’t have to use their crap. So, I’ve logged out of Twitter on every device I use. It’s no longer in my pocket, or on my desk, or anywhere else convenient. I won’t be deleting my account, but the only way I’ll be posting to Twitter will be through my blog. And I won’t be able to follow along, or check out the awesome hashtags or trending tweeters or whatever.

But! It’s 2018! How will you function? How will you stay part of communities?

I’m not going anywhere. RSS is still a thing – compare the noisy flashing algorithmic stream pushed at us by social media companies, with this:

A place where algorithms (if they’re in there at all) work to help me, not to pad anyone’s B2B enterprise advertising ponzi endeavour.

And. It’s a place where I can be done, close it, and move on with my day.

NPR: A Tenn. Man Recently Discovered The Largest Prime Number Known To Humankind. “This past week, a FedEx employee from Germantown, Tenn., made a massive discovery — and it wasn’t in any packages. John Pace found the largest prime number known to humankind. And that number goes on to more than 23 million digits.”

Thursday January 11, 7 pm

Vancouver Public Library, Joe Fortes Branch, 870 Denman Street

Come and participate in a free and free-wheeling discussion on Vancouver’s present and future, moderated by the ever-impartial me, ha ha.

I will start from the premise that Vancouver’s human diversity and urbanity is supported by its wide range of buildings, using the West End as an example, and let participants take it from there …

For further information, visit the website for the Philosophers’ Café.

A new smart home chip will enable devices to get more than ten years of battery life out of a single coin-cell battery. Announced at CES 2018, the 700-Series chip comes from Sigma Designs, the makers of the Z-Wave smart home system.

The chip has a range of over 300 feet, allowing it to reach multiple floors of a home, as well as an outside yard. Sigma Designs also says the chip is made with low-cost materials that will make it easier for developers to work with the product. The company envisions the chips being used in many household sensors, such as water leak monitors.

“Sigma’s Z-Wave 700-Series chip will completely reshape the meaning of smart home. It solves for many of today’s technological barriers, while being the most flexible, interoperable platform, bringing smart home functionality to a new level,” said Raoul Wijgergangs, vice president of Sigma Designs’ Z-Wave Business Unit, in a press statement.

“700-Series opens opportunities for new classes of sensors that weren’t possible before, while making remarkable improvements to existing device categories. 700-Series is creating a path to full home installations, moving from tens of Z-Wave devices to hundreds of Z-Wave devices per home. Our new platform assures the environment that will take homes from smart to truly intelligent.”

However, the chip is currently only compatible with the Z-Wave smart home system, meaning those with the likes of Apple’s HomeKit or Amazon’s Alexa will need a hub to bridge the different systems.

Source: Globe Newswire Via: The Verge

The post This smart home chip extends the battery life of a device to 10 years appeared first on MobileSyrup.

Android Oreo is slowly but surely gaining ground on past iterations of Android, the latest distribution numbers from Google reveal.

The newest major dessert version of the operating system bumped up to 0.7 percent of the overall Android ecosystem compared with 0.5 percent in December. The January chart also marks the first time Android 8.1 made it on the board, coming in with 0.2 percent.

While it’s a gain on last month, the percentage is still very low considering Android 8.0 was first made available through factory images in August 2017.

Meanwhile, Android 6.0 Marshmallow remains the most heavily represented operating system version, claiming 28.6 percent of Android users. Nougat 7.x follows behind with 26.3 percent of Android users and Lollipop 5.x comes in third with 25.1 percent.

The data was gathered over a seven-day period ending January 8th, 2018. For last month’s numbers, check here.

Source: Android Developers

The post Android Oreo is now installed on 0.7 percent of Android devices appeared first on MobileSyrup.