Rolandt

Essential, which launched its first smartphone, the Essential Phone, and heralded smartphones with notches and drastically minimized bezels, has been in a bit of rough waters as of late. Continue reading →

This is an election like no other. While “unprecedented” is an overused word, it seems true for this campaign more than any other since the late 1930s:

• Only three incumbents from the previous council.
• More new parties than most of us can distinguish.
• Credible independents, with a receptive electorate.
• Campaign finance rules that, with some breaking of their intentions, changed the way the game is played.
• A tumbled ballot.

Throw in a low turnout, split voting on left and right, along with a shift to densifying neighbourhoods and a decline of voters in aging communities (thanks, Andy Yan, for that data), and you have an outcome that no one can credibly predict.

I thought for awhile that this may be an election which changes the direction of Vancouver in a way that happened in 1972 when the NPA lost to TEAM.  That marked the end (and beginning) of an era.  But my sense now is, maybe not.  While there will be some momentous decisions to come, particularly with respect to neighbourhoods that haven’t seen much change in generations, the City will continue on as it has, with Council adhering to the foundational assumptions which all previous councils, regardless of ideology, have held:

• Large and continued investments in basic infrastructure and maintenance.
• Reliable emergency services.
• Gradual but not dramatic increases in property taxes, still heavily weighted to the advantage of residential over business.
• Ongoing commitment to local-area planning – but in the context of a city-wide strategy.
• Opportunistic levering of senior-government funding, especially for housing and transit.
• Continued immigration but less concentrated ethnicity.
• Disproportionate support for arts, culture and social services, providing regional-scale programs, supports and institutions.

Because we’re a rich city, we can do all that and not have much political division on the basics.  Our politics may seem extreme (and shifted to the left), but in fact we have the luxury of debating and dividing over social issues and relatively trivial interventions (bike lanes!) that keep Vancouver’s reputation for leadership and controversy intact.

After attending numerous candidates’ forums (at least for mayor and council), I’m impressed by the overall level of competence and concern among those running.  These are mostly good, sane people running for office, who care sometimes passionately, but seem capable of getting along with others.  While there are certainly characters and outliers, we’re going to be in good hands.

 

So who am I going to vote for?  I was avoiding a commitment, ostensibly maintaining an ‘objective’ persona for purposes of commentary.  But who am I kidding?  Already in this space I have profiled candidates I think worthy of office, and have been reported on the donation I made to a mayoral candidate (thanks, Charlie Smith).So here are some of the people I think would serve us well.

For Mayor:

Shauna Sylvester. 

She impresses everyone who hears her, and undoubtedly has a grasp of policy with articulated positions.  Her main asset is her ability to listen to others with the intent to forge consensus.  We’re going to need that.

 

For Councillors, in order of appearance on ballot, whom I’ve heard on the stump or interviewed:

CROOK, Adrian  (Independent)

FRY, Pete  (Green)

EVANS, Catherine, Vision

COOK, Graham  (Independent)

PAZ, Tanya  (Vision)

GRANT, Wade  (Independent)

MCDOWELL, Rob  (Independent)

YAN, Brandon 甄念本  (One Vancouver)

WIEBE, Michael  (Green)

DEAL, Heather  (Vision)

A few others for consideration: Barinder Bains, Christine Boyle, Diego Cardona, Colleen Hardwick, Abubakar Khan, Erin Shum.

 

As I’ve said to others, despite all the credible Independents, we could conceivably end up with a majority on council from one party, maybe the NPA – depending on the voter turnout, a good ground game, and an electorate who use party affiliation as a way to navigate the ballot.  Though Vancouver since the war has never voted for a mayor without an accompanying council majority, this election could be (wait for it) … unprecedented.

 

Here’s what I’ll be watching for:

• Hidden voting blocks, particularly from the South and Southeast Vancouver.
• Changes from past voting patterns (though I’ll leave the details to Andy Yan).
• Resiliency of the slates, and whether any new party has a chance of survival.
• What difference money (or lack of it) has made, and where it came from.
• Generational differences.
• Push-back from the conservationist status quo.
• The emergence of a consensus on city direction, if any.

 

Firnally, an observation on the one thing we always hear in every campaign: “Let’s get the politics out of City Hall.”

Hah.

Politics is the way we govern and allocate resources, including power.  That ain’t going away, unless we choose (as others seem to be) an authoritarian alternative.

Secondly with all the newcomers, there will be more politics going on at 12th and Cambie than we’ve seen in awhile, especially if there’s not a clear majority of interests capable of governing.  For those who ran on the illusion that they won’t be ‘political’ when elected, I look forward to your education.

We’ll do our best to document it in Price Tags and (soon to come) Price Talks, our upcoming podcast.

Jason Snell, writing for Macworld on the announcement of Photoshop coming to iPad next year:

Adobe’s move to iPad instantly makes everyone who knows, loves, or relies on Photoshop a possible candidate for an iPad Pro. And make no mistake, the iPad Pro is already plenty powerful enough to run Photoshop, and with the Apple Pencil it’s got an input method that will satisfy most graphics pros. Even better, Adobe has said that it will be building in cloud syncing for Photoshop files, so that you’ll be able to seamlessly hand off projects directly from one device to another.

A lot of the criticism of the iPad Pro as a flawed tool for doing real work comes down to software. The hardware is capable—but where’s the software? These arguments have been weak for a while now—I think Microsoft Office for iPad is aces, and Apple’s iWork apps are remarkably capable, too—but with every major app that arrives on the platform, the quieter that criticism has to get. Adobe’s also bringing a simplified version of Premiere, called Premiere Rush, to the iPad. I wonder if Apple’s considering just how Final Cut and Logic might work on the iPad?

As I've been arguing for a while now, I believe we're witnessing a shift in how tech companies – both platform owners and development studios – approach desktop and tablet software. Multiple factors – from better-looking displays and more powerful GPUs to cloud-based file management and subscriptions – are converging to make it possible to have a consistent app experience on every device you have without compromise. In this transition, iPad versions of desktop apps will be treated less like "companion" apps to a "real" desktop one and more like the same app, with the same features, optimized for touch and capable of adapting to the kind of computer it is running on (and adaptivity becomes especially important when you start considering external display output, for instance).

Photoshop, as Snell writes, is a first step. If Apple is truly pushing this vision forward, perhaps it's time they also start treating the iPad as a place for real pro apps, not just companion utilities of macOS apps.

→ Source: macworld.com

Anne Gibson writes, in To whom does the burden fall?, about accessibility:

When is it the responsibility of someone with a disability to use unnamed tools to somehow make your content accessible, when your organization has not done so yourself?

Never. It is never their responsibility.

Read the entire post: it’s a well-worded call to arms.

I just posted a tech note for Rainier’s scripting language, Ballard.

Feedback is welcome, of course. Best place is on the Slack group. (You can find my email address near the bottom of this page and then email me to ask for an invitation.)

(Note: other tech notes on the Rainier site are out of date, so I’d skip ’em for now.)

The Paperwhite is my Kindle of choice. The screen is the easiest to read, designed to have the same contrast as paper and no glare so you can read in any light. Unlike paper, you can read it in low light because it has it’s own light. I read. A lot. Books are still my favorite technology for this. But the Paperwhite is next best. It’s better than books for travel because I can take ten books with me on a road trip, no problem.

 

 

The new Paperwhite is thinner, lighter, pairs with Audible, and it’s waterproof! I could read in the bath. I have it in my cart. I’m just waiting for a weak moment to click buy.

 

I have been pestering Amazon for an Echo that works in the car for years. Every time I go on a road trip, I am barely an hour into the trip before I start asking Alexa questions and cursing her refusal to travel.

 

 

Well, they finally listened to me! This is so gratifying.

The Echo Auto is available for pre-order. It’s a great deal if you are willing to order a thing that won’t arrive for a while. Pre-orders are $25.

I’m often surprised by people who run large, mature, communities and haven’t segmented their membership in any meaningful way.

They still treat their communities as one massive lump of people.

They ask all their members to do the same thing at the same time regardless of how long someone has been a member or how active they have been.

In The Indispensable Community, I noted the reason most people don’t participate in your community is they’re simply not able to.

A solution to this is to properly segment your members and develop a series of emails, unique weekly messages, and on-site calls to action (CTAs) they will receive.

The most common one is the onboarding journey for newcomers. But this is just one of several you should develop.

Over time you should be able to segment every member by their current level of participation and adapt your messages to each accordingly.

A simple system is shown below:

(click for full-sized image)

You can set up default rules (by direct access to server logs or using the current platform) to show each group different messages based upon their current level of participation.

Based upon this, you can assign them to a specific group which receives a different experience.

This would cover the automated email series they receive, the calls to action they might see on the website, and what kind of weekly email they are sent. You can see an example of this below:

(click here for the full-sized image)

These calls to action should be based upon your segmented survey results and interviews with each group.

They must also naturally lead into the goal of your community.

The further you develop the community, the more complex these rules might become. For example, as you’re getting started:

(click here for full image)

Over time, you want to continue to push the boundary here. Develop more specific rules for unique groups of members. Guide them to make their best possible contribution to the community.

You should constantly use your data (open rates, click-through rates, cohort retention rates) to gradually refine each message/call to action to gain the greatest number of valuable behaviors within the community.

There are two sources of complexity in software: the complexity inherent in the domain (essential complexity) and the complexity we add as programmers due to the platform or due to bad programming practices (accidental complexity).

Transcript

Eric Normand: What is the main obstacle to writing correct software on time and on budget? Hi, my name is Eric Normand, and these are my thoughts on functional programming.

There is a book called “The Mythical Man-Month” that talks about one of the main challenges of software is its complexity. That software is just complex. It’s just going to take time and energy to make it correct, to make it work for us. I think that’s fair to say. In the book, Fred Brooks, the author, talks about two kinds of complexity, essential complexity and accidental complexity.

Essential complexity is a complexity you cannot avoid and accidental complexity is complexity that you add, that you didn’t need to. There might have been a way that you could’ve gotten along without it.

For what it’s worth, that’s a fair way to divide it up. There is a paper about 14 years ago called “Out of the Tar Pit.” This is a very influential paper in the functional programming world, because it does a little bit better at dividing up the complexity, of defining the two types of complexity than Fred Brooks did.

For instance, Fred Brooks said, “Oh, there’s just a lot of state in software and that’s unavoidable.” As functional programmers, talking about state as unavoidable, we know that’s not true. You can avoid it.

This paper defines essential complexity, I think, in a more useful way where essential complexity is complexity that is due to the domain. If you are going to be making a piece of software about rocket science — rocket science is just complex by itself — your software has to have at least that much complexity, as much complexity as rocket science.

All of that is due to the domain. It’s essential. You wouldn’t be doing rocket science correctly if you didn’t have that complexity in it. However, there is another kind of complexity, which is all the complexity that we add as software developers. This is everything that has nothing to do with rocket science.

This is threads, the file system, exceptions, syntax errors, types. All that stuff is complexity that is added on to the system if it adds complexity. Some things you could argue. These are actually removing complexity.

In general, if there is some complexity and it’s due to something that when you name it, it is not naming a rocket-science thing it’s naming a computing-thing, that is actually accidental complexity.

What this gives us is a minimum floor for our complexity. Everything else above that is all accidental. We can work with it to reduce the complexity or at least manage it better. Know that we’re introducing complexity but we’re managing it.

I say we’re introducing complexity. For instance, the platform you’re running on is going to have complexity. It’s going to have accidental complexity by itself. That means you’re making Web-based rocket science software.

Now you have to deal with browsers, the DOM, the AJAX requests, HTTP. All this other stuff that has nothing to do with rocket science, that just has its own semantics and some of those semantics have complexity to them.

You have to deal with timeouts of your network requests. You have to deal with all the different response codes when maybe you only needed two. These are the kinds of complexities that start adding up.

In general, we see in most software that the accidental complexity swamps out. It’s way bigger than the essential complexity. That means that in your rocket science software, most of the complexity is due to the implementation and not to rocket science itself, which is a sad fact, but that’s also optimistic.

It means there’s a lot of room for improvement. That we’re doing this to ourselves as programmers. We’re adding in…Some things are maybe functional or operational requirements that are not part of rocket science.

You might have a functional requirement that says, “We have to implement all of rocket science.” That’s great. Then you might have a requirement that says, “It has to run in the Web browser.” This has to be Web-based software. Now, it’s a requirement.

You’re going to have to take on all of this complexity. It’s something that the business has to decide. That the deliverability, the availability of the Web as a platform has its benefits versus the cost of all that complexity, because complexity cost money, cost time, developer time dealing with.

The real reason it costs time is because when you have something that’s complex, it’s hard to hold in your head. We have limited space if you will. It’s a metaphor. We have limited capacity in our heads, in our minds to understand complex things.

The more complex it is, the harder it is to hold in our head. That’s going to cause bugs. We’re going to forget things. As the system gets more complex, things slip through the cracks, and so we need help. We need to do something about that complexity.

The Tar Paper book out of the Tar…Sorry, Tar Pit not Tar Paper. The Tar Pit paper is all about using functional programming to reduce complexity. It does a good job of beginning that search. It’s laying the groundwork for how functional programming can reduce complexity.

I feel like there is a lot left out that we still need to deal with. For instance, a kind of hand waves around state, about mutable state and storing things durably over time. That’s fine. It is a paper, it had its scope. It’s still a very great paper. I suggest you all read it.

One thing that we can do besides just eliminating unnecessary stuff that we’re adding, like do we really need mutable state here? Maybe not. Do we really need extra threads here? Maybe not. Those things are obvious, eliminate them. Sure.

There’s got to be some stuff for managing it. Maybe for making it easier to work with. These are like developmental concerns. For instance, if you could encapsulate the complexity behind something that is a good abstraction, let’s call it that.

If you could somehow take all of the complexity of reading in files and storing them and stuff, and just turning it into a simple interface that you don’t have to worry about it. If this complex thing is written correctly, I can stop thinking about it.

That’s one way of dealing with complexity is to encapsulate it. Another way is to cut stuff into smaller pieces. If you have two complex pieces…I’m going to get into this more in a future episode.

If you have two complex pieces and you break it up into…Sorry, if you have one big complex piece. Imagine its complexity, and you broke it up. The complexity, not only is it easier to fit in your head because it’s smaller, it’s two smaller things, but the complexity is actually cut in more than half for each piece.

The reason is that complexity compounds super linearly depending on the type of complexity. Just as an example, the complexity of the number of code paths you have in, say, a routine, a function, that complexity multiplies.

Let’s say, it’s a simple case. You just branch into two possible…conditional has two branches if it’s an IF statement with a THEN and an ELSE. Every time you add one of those to your function, it will multiply the number of possible code path by two. If you get rid of one, you’re actually reducing the number of code passed by…You’re dividing it by two.

If you multiply them out when they’re in a big single unit like a one function with 10 code path, that’s 2^10 possible code paths. Sorry, you have 10 conditionals with 2 branches each. That’s 2^10 code paths.

If you cut that in half, you have two functions with five branches each. Let’s say you could do that. Sorry, five conditionals each, two branches on each conditional, that’s 2^5+2^5. That’s way less. Before you add 2^5*2^5 that’s 2^10, but if you do 2^5+2^5 you have significantly reduced the amount of complexity. With tricks like this we’re able tricks…

There are skillful manipulations of the units that we have to reduce the complexity and just make it easier to work with. The code should do the same thing but have fewer…It’s less to hold in your head. Let’s say it that way.

All right. My name is Eric Normand. This has been a thought about functional programming. You can reach me over email at eric@lispcast.com. I do enjoy getting people’s emails and hearing about your thoughts on my thoughts.

You can also reach me on Twitter. I’m @ericnormand. Follow me, message me, and mention me. We’ll get into a cool discussion. I really appreciate doing that. Thank you so much for listening. Subscribe where you subscribe to this. You’ll hear about the next one when it comes out. Awesome. Thanks so much. Bye.

The post Sources of complexity in software appeared first on LispCast.

Today we are excited to launch a new add-on board for your Raspberry Pi: the Raspberry Pi TV HAT, on sale now at $21.50.

The TV HAT connects to the 40-pin GPIO header and to a suitable antenna, allowing your Raspberry Pi to receive DVB-T2 television broadcasts.

Watch TV with your Raspberry Pi

With the board, you can receive and view television on a Raspberry Pi, or you can use your Pi as a server to stream television over a network to other devices. The TV HAT works with all 40-pin GPIO Raspberry Pi boards when running as a server. If you want to watch TV on the Pi itself, we recommend using a Pi 2, 3, or 3B+, as you may need more processing power for this.

Stream television over your network

Viewing television is not restricted to Raspberry Pi computers: with a TV HAT connected to your network, you can view streams on any network-connected device. That includes other computers, mobile phones, and tablets. You can find instructions for setting up your TV HAT in our step-by-step guide.

New HAT form factor

The Raspberry Pi TV HAT follows a new form factor of HAT (Hardware Attached on Top), which we are also announcing today. The TV HAT is a half-size HAT that matches the outline of Raspberry Pi Zero boards. A new HAT spec is available now. No features have changed electrically – this is a purely mechanical change.

The TV HAT has three bolt holes; we omitted the fourth so that the HAT can be placed on a large-size Pi without obstructing the display connector.

The board comes with a set of mechanical spacers, a 40-way header, and an aerial adaptor.

Licences

Digital Video Broadcast (DVB) is a widely adopted standard for transmitting broadcast television; see countries that have adopted the DVB standard here.

Initially, we will be offering the TV HAT in Europe only. Compliance work is already underway to open other DVB-T2 regions. If you purchase a TV HAT, you must have the appropriate licence or approval to receive broadcast television. You can find a list of licences for Europe here. If in doubt, please contact your local licensing body.

The Raspberry Pi TV HAT opens up some fantastic opportunities for people looking to embed a TV receiver into their networks. Head over to the TV HAT product page to find out where to get hold of yours. We can’t wait to see what you use it for!

The post Introducing the Raspberry Pi TV HAT appeared first on Raspberry Pi.

Ich schaue mir die ganzen Smartphone-Vergleiche an und bin etwas müde. Mich erinnert das an eine längst vergangene Zeit, in der ich Textverarbeitungsprogramm verglichen habe. Word vs WordPerfect vs. Ami Pro. Das wurde irgendwann sehr abstrus.

Und so kommt mir das heute wieder vor, wenn ich die Vergleiche von Smartphone-Kameras sehe. Irgendwelche Unterschiede sieht man nur noch, wenn man unmögliche Bilder macht. Also brutale Kontraste, möglichst wenig Licht, verwirrende Linien. Wozu das alles? 'Mein Handy ist stärker als Dein Fax.'

Kauf ich mir jetzt ein iPhone Xs, ein Xr, oder gar ein Xs Max? Das fragt sich doch niemand, der Samsung-Handys mag. Auch nicht, wenn ein paar Testbilder in absoluter Dunkelheit etwas weniger rauschen.

Vielleicht sollten wir mal andere Fragen stellen. Etwa: Was passiert eigentlich mit den ganzen Daten, die so ein Sensor-Paket fortwährend liefert?

Malte fragte mich was:

@vowe hast du einen Tip zum Play 3: Noch kaufen oder lieber warten? 16m2 Raum.

— Malte Widenka (@widenka) October 18, 2018

Hintergrund: Sonos hat den Play:3 eingestellt. Endlich, möchte ich beinahe sagen. Das war der älteste Player im Programm und meiner Ansicht nach dem Sonos ONE unterlegen, gleichzeitig aber teurer. Die Frage ist: Wird Sonos einen neuen Play:3 bauen? Ich glaube nicht. Die meisten Leute sind mit dem Sonos ONE zufrieden. Und wenn man mehr will, dann sollte man sich den Play:5 kaufen. Wer nur den alten Play:5 kennt, der verpasst was. Das 2015 vorgestellte Modell ist unfassbar viel besser. Egal ob ganz leise oder bis 11 aufgedreht, der klingt einfach fantastisch mit eine sehr breiten Soundstage. Und wenn es etwas weniger sein soll, einfach Sonos Beam. Auch ohne Fernseher.

Cecily W. 🧟‍♀️ @skeskali
The Making (and Unmaking) of Paul’s Boutique vulture.com/2018/10/excerp… via @vulture

Hi! Do you like computers? Do you like people? Do you want to work with Mirko, David, Gregor, Ivan, Anna, Hendrik, Hans, Elana and Lisa? Nice! We have a job for you:

We’re hiring a full-time client-facing software engineer in Berlin (Prenzlauer Berg).

Why? Well, although our charting tool is used primarily by journalists, our customer base is growing and diversifying, and some of our users come with special requirements and challenges. We want to be able to accommodate these people as well. Providing them with a flawless Datawrapper experience will be your job.

What you’ll be doing:

• Developing new visualization features for specific customer groups. For example, an analyst at a financial institution might need different charting features than a data journalist at a local newspaper. We work with both, so that will be part of what you’re responsible for!
• Extending Datawrapper to make sure it works well with large customer teams. When one person uses Datawrapper on their own, creating and organizing charts is pretty straight-forward. When there are hundreds of people creating charts in a large team, not so much! Ensuring that even the largest of our customers’ teams don’t hit any walls when using Datawrapper will be part of this job.
• Building & maintaining integrations with other software and tools. There are all kinds of other apps and tools that Datawrapper interacts with in the real world, like CMS’s and databases. Part of your job will be ensuring that those integrations are easy to build and run smoothly.

Who we’re looking for:

• We’re looking for a full stack web developer to join our Berlin development team, preferrably full-time, but open to flexible work time arrangements.
• You will have a full, regular employment contract. Due to the nature of this job, it will not be possible to do this job entirely remote. Please save yourself and us some time and only apply if you want to work with us in Berlin.
• On the technical side, most of the work we’re doing is front end development work in JavaScript/ES6, D3.js, Bootstrap and Svelte. There’s a PHP and MySQL backend as well, but that won’t be too much of your concern.
• We’re looking for somebody who has worked in web development before, but you don’t need to have specific experience with our tooling or choice of frameworks. We’re happy to show you how our stack works.

What the „client-facing“ part entails:

• A significant part of the job will involve interacting with users and customers. be it by phone, video call or email. We encourage everybody in our company to do this, but in this role it will be specifically pronounced.
• That means we’re looking for someone with good communication, interpersonal and written skills.
• Strong English skills will also be necessary, as our users and customers sit all over the world.
• Not a must-have, but a plus: German skills, interest in or experience with data visualization, experience working in a software company.
• If you have any prior work you can show us, open-source or not, please feel free to include it in your application. We’d love to take a look at it. Even if you don’t, please don’t feel discouraged to apply.

What we can offer:

• A big desk in our office in Berlin Prenzlauer Berg, where seven of us work (Ivan, Lisa, Anna, Gregor, Elana, Hans & David). We have a massive library of data vis books, a coffee machine, tea en masse & interesting conversations about mapping, data vis and UX. Also, we honor lunch breaks. That’s where we sit:

• Flexible working hours. We’re looking for someone who wants to work for us at least four days a week. There’s no 9-to-5 culture in our office, though. Some people come at 11 am, some leave at 4 pm, others like to work from home from time to time.

• A question-happy, communication-happy atmosphere. We’re all learning, and we want you to learn with us. If someone has an idea or a problem, we just talk. No meetings for most of us, a bit of Slack, lots of fun.

• Oh, and you’ll get money for doing this job.

We want you to apply especially if you’re from a group that’s underrepresented in our office. (That includes women, still, but we’re working on it!) Also: We don’t care about CVs, just skills and attitude. If you don’t find yourself 100% in the description, write Lisa an email anyway. Talk a bit about yourself and how your skills & experience could be a good fit for this job, and ask us aaaaall the questions you might have:

→ lisa@datawrapper.de

We’re looking forward to hearing from you!

Today users typically use computers through graphics user interfaces -- GUIs. Only programmers use the command line. But that is changing as more people discover the power of the command line just as they learned how to wire their own home entertainment systems in the days of Hi Fi.
It is no longer a relic of the past but rather a path to the future.

mkalus shared this story from existentialcoms on Twitter.

---

The ATS programming language supports defining Generalized Algebraic Data Types (GADTS). They allow defining datatypes where the constructors for the datatype are explicitly defined by the programmer. This has a number of uses and I'll go through some examples in this post. GADTs are sometimes referred to as Guarded Recursive Datatypes.

Some useful resources for reading up on GADTs that I used to write this post are:

• Wikipedia page on GADT
• Haskell/GADT Wikibook
• GADTs for Dummies
• Guarded Recursive Datatype Constructors

The examples here were tested with ATS2-0.3.11.

# Arithmetic Expressions

This is probably the most common demonstration of GADT usage and it's useful to see how to do it in ATS. The example is taken from the Haskell/GADT Wikibook.

First we'll create datatype to represent a simple expression language, and write an evaluation function for it, without using GADTs:

#include "share/atspre_define.hats"
#include "share/atspre_staload.hats"

datatype Expr  =
  | I of int
  | Add of (Expr, Expr)
  | Mul of (Expr, Expr)

fun eval (x:Expr): int =
  case+ x of
  | I i => i
  | Add (t1, t2) => eval(t1) + eval(t2)
  | Mul (t1, t2) => eval(t1) * eval(t2)


implement main0() = let
  val term = Mul(I(2), I(4))
  val res = eval(term)
in
  println!("res=", res)
end

Expr is a datatype with three constructors. I represents an integer, Add adds two expressions together and Mul multiples two expressions. The eval function pattern matches on these and evaluates them. The example can be compiled with the following if placed in a file arith1.dats:

$ patscc -DATS_MEMALLOC_LIBC -o arith1 arith1.dats
$ ./arith1
res=8

Now we extend the expression language with another type, booleans, and add an Expr constructor to compare for equality:

datatype Expr  =
  | I of int
  | B of bool
  | Add of (Expr, Expr)
  | Mul of (Expr, Expr)
  | Eq of (Expr, Expr)

(* Does not typecheck *)
fun eval (x:Expr): int =
  case+ x of
  | I i => i
  | B b => b
  | Add (t1, t2) => eval(t1) + eval(t2)
  | Mul (t1, t2) => eval(t1) * eval(t2)
  | Eq (t1, t2) => eval(t1) = eval(t2)

This code fails to typecheck - the eval function is defined to return an int but the B b pattern match returns a boolean. We can work around this by making the result value of eval return a datatype that can represent either an int or a bool but then we have to add code throughout eval to detect the invalid addition or multiplication of a boolean and raise a runtime error. Ideally we'd like to have make it impossible to construct invalid expressions such that they error out at compile time.

We can imagine the type constructors for Expr as if they were functions with a type signature. The type signature of the constructors would be:

fun I(n:int): Expr
fun B(b:bool): Expr
fun Add(t1:Expr, t2:Expr): Expr
fun Mul(t1:Expr, t1:Expr): Expr
fun Eq(t1:Expr, t2:Expr): Expr

The problem here is that Add and Mul both take Expr as arguments but we want to restrict them to integer expressions only - we need to differentiate between integer and boolean expressions. We'd like to add a type index to the Expr datatype that indicates if it is a boolean or an integer expression and change the constructors so they have types like:

fun I(n:int): Expr int
fun B(b:bool): Expr bool
fun Add(t1:Expr int, t2:Expr int): Expr int
fun Mul(t1:Expr int, t1:Expr int): Expr int
fun Eq(t1:Expr int, t2:Expr int): Expr bool

Using these constructors would make it impossible to create an expression that would give a runtime error in an eval function. Creating an Expr with a type index looks like:

datatype Expr(a:t@ype)  =
  | I(a) of int
  | B(a) of bool
  | Add(a) of (Expr int, Expr int)
  | Mul(a) of (Expr int, Expr int)
  | Eq(a) of (Expr int, Expr int)

This adds a type index of sort t@ype. A 'sort' in ATS is the type of type indexes. The t@ype is for types that have a flat memory structure of an unknown size. The '@' sigil looks odd inside the name, but '@' is used elsewhere in ATS when defining flat records and tuples which is a useful mnemonic for remembering what the '@' within the sort name means.

This doesn't help our case though as the type signatures for the constructors would be:

fun I(n:int): Expr a
fun B(b:bool): Expr a
fun Add(t1:Expr int, t2:Expr int): Expr a
fun Mul(t1:Expr int, t1:Expr int): Expr a
fun Eq(t1:Expr int, t2:Expr int): Expr a

There is still the problem that an Expr a is not an Expr int for Add, Mul and Eq, and requiring runtime errors when pattern matching. This is where GADTs come in. GADTs enable defining a datatype that provides constructors where the generic a of the type index can be constrained to a specific type, different for each constructor. The Expr datatype becomes:

datatype Expr(t@ype)  =
  | I(int) of int
  | B(bool) of bool
  | Add(int) of (Expr int, Expr int)
  | Mul(int) of (Expr int, Expr int)
  | Eq(bool) of (Expr int, Expr int)

The constructor type signature now match those that we wanted earlier and it becomes possible to check at compile time for invalid expressions. The eval functions looks similar, but is parameterized over the type index:

fun{a:t@ype} eval(x:Expr a): a =
  case+ x of
  | I i => i
  | B b => b
  | Add (t1, t2) => eval(t1) + eval(t2)
  | Mul (t1, t2) => eval(t1) * eval(t2)
  | Eq (t1, t2) => eval(t1) = eval(t2)

The "{a:t@ype}" syntax following fun is ATS' way of defining a function template where a is the template argument. ATS will generate a new function specific for each a type used in the program.

An example main function to demonstrate the new GADT enabled Expr and eval:

implement main0() = let
  val term1 = Eq(I(5), Add(I(1), I(4)))
  val term2 = Mul(I(2), I(4))
  val res1 = eval(term1)
  val res2 = eval(term2)
in
  println!("res1=", res1, " and res2=", res2)
end

$ patscc -DATS_MEMALLOC_LIBC -o arith2 arith2.dats
$ ./arith2
res1=true and res2=8

You may have noticed that our Expr type can't represent equality between booleans, or between booleans and integers. It's defined to only allow equality between integers. It's possible to make equality polymorphic but I'll go through this later as it brings up some more complicated edge cases in types with ATS beyond just using GADTs.

# Typesafe sprintf

This example of GADT usage in ATS tries to implement a sprintf function that allows providing a format specification to sprintf which then processes it and accepts arguments of types as defined by the format specification.

The format specification is defined as a GADT:

datatype Format (a:type) =
  | I(int -<cloref1> a) of (Format a)
  | S_(a) of (string, Format a)
  | S0(string) of string

Each constructor represents part of a format string. The type index is the type that sprintf will return given a format string for that type. sprintf is declared as:

fun sprintf {a:type} (fmt: Format a): a

Here are some example invocations and the types that should result:

// Returns a string
sprintf (S0 "hello")

// Returns a string
sprintf (S_ ("hello", S0 "world"))

// Returns a function that takes an int and returns a string
sprintf (I (S0 "<- is a number"))

The last example shows how sprintf emulates variable arguments using closures. By returning a function any immediately following tokens are treated as arguments to that function. For example:

sprintf (I (S0 "<- is a number")) 42
(int -> string) 42

With some syntactic sugar using currying we can make this look nicer. Curried functions is a feature that isn't often used in ATS as it requires the garbage collector (to clean up partially curried functions) and performance is diminished due to the allocation of closures but it's useful for this example.

With the Format datatype defined, here's the implementation of sprintf:

fun sprintf {a:type} (fmt: Format a): a = let
  fun aux {a:type}(pre: string, fmt': Format a): a =
    case fmt' of
    | I fmt => (lam (i) => aux(append(pre, int2string(i)), fmt))
    | S_ (s, fmt) => aux(append(pre, s), fmt)
    | S0 s => append(pre, s)
in
  aux("", fmt)
end

It uses an inner function, aux, that does the work of deconstructing the format argument and returning a closure when needed, and appending strings as the result string is computed. For this example I'm cheating with memory management to keep the focus on GADT, and off dealing with the intricacies of linear strings. The example should be run with the garbage collector to free the allocated strings.

Here's an example of executing what we have so far:

implement main0() = let
  val fmt = S_ ("X: ", (I (S_ (" Y: ", (I (S0 ""))))))
  val s = sprintf fmt 5 10
in
  println!(s)
end

$ ./format
X: 5 Y: 10

The format string is pretty ugly though. Some helper functions make it a bit more friendly:

fun Str {a:type} (s: string) (fmt: Format a) = S_ (s, fmt)
fun Int {a:type} (fmt: Format a) = I (fmt)
fun End (s:string) = S0 (s)

infixr 0 >:
macdef >: (f, x) = ,(f) ,(x)

Now the format definition is:

val fmt = Str "X: " >: Int >: Str " Y: " >: Int >: End ""

The string handling functions that I threw together to append strings and convert an integer to a string without dealing with linear strings follow.

fun append(s0: string, s1: string): string = let
  extern castfn from(s:string):<> Strptr1
  extern castfn to(s:Strptr0):<> string
  extern prfun drop(s:Strptr1):<> void
  val s0' = from(s0)
  val s1' = from(s1)
  val r = strptr_append(s0', s1')
  prval () = drop(s0')
  prval () = drop(s1')
in
  to(r)
end

fun int2string(x: int): string =
  tostring(g0int2string x) where {
    extern castfn tostring(Strptr0):<> string
  }

# Issues

These example of GADT usage were pulled from the papers and articles mentioned at the beginning of the post. They were written for Haskell or Dependent ML (a predecessor to ATS). There may be better ways of approaching the problem in ATS and some constraints on the way ATS generates C code limits how GADTs can be used. One example of the limitation was mentioned in the first example of the expression evaluator.

If the Expr datatype is changed so that Eq can work on any type, not just int, then a compile error results:

datatype Expr(a:t@ype)  =
  | I(a) of int
  | B(a) of bool
  | Add(a) of (Expr int, Expr int)
  | Mul(a) of (Expr int, Expr int)
  | Eq(a) of (Expr a, Expr a)

The error occurs due to the Eq branch in the case statement in eval:

fun{a:t@ype} eval(x:Expr a): a =
  case+ x of
  | I i => i
  | B b => b
  | Add (t1, t2) => eval(t1) + eval(t2)
  | Mul (t1, t2) => eval(t1) * eval(t2)
  | Eq (t1, t2) => eval(t1) = eval(t2)

The compiler is unable to find a match for the overloaded = call for the general case of any a (vs the specific case of int as it was before). This is something I've written about before and the workaround in that post gets us past that error:

extern fun{a:t@ype} equals(t1:a, t2:a): bool
implement equals<int>(t1,t2) = g0int_eq(t1,t2)
implement equals<bool>(t1,t2) = eq_bool0_bool0(t1,t2)

fun{a:t@ype} eval(x:Expr a): a =
  case+ x of
  | I i => i
  | B b => b
  | Add (t1, t2) => eval(t1) + eval(t2)
  | Mul (t1, t2) => eval(t1) * eval(t2)
  | Eq (t1, t2) => equals(eval(t1), eval (t2))

Now the program typechecks but fails to compile the generated C code. This can usually be resolved by explicitly stating the template parameters in template function calls:

fun{a:t@ype} eval(x:Expr a): a =
  case+ x of
  | I i => i
  | B b => b
  | Add (t1, t2) => eval<int>(t1) + eval<int>(t2)
  | Mul (t1, t2) => eval<int>(t1) * eval<int>(t2)
  | Eq (t1, t2) => equals<?>(eval<?>(t1), eval<?>(t2))

The problem here is what types to put in the '?' in this snippet? The Expr type defines this as being any a but we want to constrain it to the index used by t1 and t2 but I don't think ATS allows us to declare that. This mailing list thread discusses the issue with some workarounds.

mkalus shared this story .

---

Google Chrome 70 is available now, bringing necessary fixes following controversial changes to sign-in practices in Chrome 69. Additionally, the new update brings support for Progressive Web Apps on Windows and a new video codec.

First and foremost is the fix to a controversial new setting. The previous version of Chrome changed how sign-in works. Instead of separating Google website sign-in and Chrome sign-in for syncing bookmarks, Google combined the two.

The company argued that the feature would help users by making it easier to see whether they were signed in. However, it also made it harder to determine if your Chrome browsing data was syncing to Google. While the search giant claimed users had to opt-in to sync, the reality was the complex UI made it easy to opt-in by accident.

Chrome 70 partially resolves this issue by adding a toggle to disable this sign-in behaviour. However, users have to go digging through the settings menu to find it. Additionally, the process is opt-out, meaning the browser will still sign users in when they sign into a Google website by default.

Additionally, Chrome 70 features some slight interface adjustments to clarify the difference between signing into Chrome and syncing browsing data with Google.

While the changes are welcome, it feels like it’s not enough to keep users from accidentally syncing data.

Progressive Web Apps and new video codecs

Aside from the changes to Chrome sign-in, the addition of Progressive Web Apps (PWAs) is certainly welcome.

PWAs make it easy for companies to build native Windows apps — in a sense. Instead of creating a separate desktop version of an app, a service like Twitter can create a PWA, which essentially takes the website out of the browser window and puts it in a native Windows environment.

Mobile devices popularized PWAs. Twitter is probably one of the best examples, which has essentially turned its mobile web page into a mirror of its mobile app. Users can add the web page to their home screen, which gives them an app icon to launch Twitter quickly. Additionally, users can get notifications and even use it offline — to the extent you can use Twitter offline.

Chrome 70 brings this functionality to Chrome users on Windows. Before Chrome 70, if you want to use PWAs on Windows, you had to go through Edge.

Finally, Chrome 70 brings a new video codec to the browser. The AV1 codec offers better compression, meaning online videos that support the format should use less data while maintaining high visual fidelity.

Google is also taking its next step in the fight against the insecure web. The ‘Not secure’ address bar tag on HTTP websites will now turn red, further highlighting sites that aren’t using the more secure HTTPS format.

Chrome 70 was also going to have an updated blocker for autoplaying media, but Google delayed it until Chrome 71.

Source: The Verge

The post Chrome 70 brings changes to controversial sign-in, support for PWAs appeared first on MobileSyrup.

cartoon by the late, wonderful Charles Barsotti

This past weekend I attended a get-together of about 20 enthusiastic, knowledgeable people on the subject of radical non-duality, organized around the (rare) visit of Jim Newman (Non-Duality Dude) to North America.

The message we shared was the same elegant, uncompromising, hopeless message I’ve written about ad nauseam on this blog. The gathering was a deep dive into that message and its implications (for no one), and was relatively free of the questions and assertions about spirituality, enlightenment, process, purpose and journey that (IMO) indicate a lack of understanding of the radical non-duality message, and which often arise in such meetings. Many thanks to Rita and Jim and the organizers and participants who made it so thought-provoking, and such fun.

While I have, for now at least, fully embraced this message (it just makes sense to me intellectually and intuitively, resonates in a way I can’t explain, and jibes with what science is now beginning to postulate about the nature of time, space and the self), I noticed that my self was furiously asserting itself throughout the weekend, despite my determination to just sit back and pay attention. I caught my self (but of course couldn’t stop my self from):

• trying to impress everyone
• seeking reassurance that my understanding and ideas about the message were ‘right’
• feeling jealous of those who seemed somehow closer to the ‘falling away of the self’
• being absurdly curious about others’ description of ‘glimpses’ (for me the jury’s still out on whether what I described as a ‘glimpse’ two years ago was in some sense a brief ‘falling away of my self’, or was just wishful thinking, another experience of my self)

Who was ‘I’ trying to impress? Not the (apparently) smartest and most attractive and most equanimous people in the room, not really. I was trying to impress my self, reassure my self. It was my self that was jealous and curious and reactive. None of my behaviour had anything to do with anyone else in the room. It was, sadly, all about me, scared, lost me, hopefully (if not expectantly) and impossibly seeking, to realize, or at least to more fully know and appreciate, the truth of this message. And it was me who then felt ashamed of my behaviour, disappointed in my self, angry with my self, absorbed in self-ish anxiety.

This was and is, of course, the only way I could have and can behave. No one really has any self control, or control over anything. But that didn’t make my behaviour any less discouraging to observe.

I think this is likely a universal attribute of the self, this compulsion to impress, to get attention and appreciation and reassurance, and to be reactive and absorbed with self-judgement. That is not to diminish in any way the role that trauma and abuse play in the chronic mental struggle and misery that many (most?) suffer with. Look at the most obvious public example, Der Drumpf, and you can see the acting out and reacting to some dreadful constantly re-triggered past trauma, in the desperate seeking to impress, for endless attention and appreciation and reassurance, and in the fierce, compulsive, reactive negative emotions that absolutely define him.

But even without a traumatic past, my sense is that every self, in the desperate search to be free of the unsatisfactory, terrifying sense of separation from all-that-is, is endlessly driven to impress and to get reassurance that it is on the right track, that it is really OK, and that it is not utterly alone. We can’t help our selves. We are all ceaselessly trying to heal ourselves (our selves) and others we care about.

In radical non-duality terms, this healing effort is a manifestation of the attempt to make the unescapable prison of the self more comfortable. Mine has probably always been more comfortable than most, and my appreciation of the message of radical non-duality seems to have made it more so. My anger now seems to dissipate faster; my fears, once they’re recognized as that, and seen as unfounded and unhelpful, seem to be less overwhelming.

Most notably, my self has found that it is somewhat liberating to realize, at least intellectually, that it has no choice, no free will, no control over or responsibility for anything. That no one is to blame. Despite the apparent complexity of reality and of agency, it’s actually even simpler and more hopeless than that. There ‘simply’ is no you that can do anything.

Somehow to me, everything seems a bit easier with that perspective. Each time I thought up a question to ask Jim, thinking a bit made me realize I already knew the answer, that it truly is even simpler and more hopeless than we can imagine. Obvious, even.

We are conditioned to think of our selves as ‘residing’ within a particular brain and body. So it was illuminating to hear Jim remind us that “the me (the self) arises simultaneously in everything”. Not only am ‘I’ an illusion, but the perception that ‘I’ am located in a particular place is also an illusion. Everything separate is an imagining of the self.

I find this mind-blowing. Why do we have this sense of location? Actually, for no reason, but it is conceivable that the (self-)invention of the self requires a pretty heavy-duty brain to conjure up, and requires the affirmation of its ‘reality’ through the feelings of the senses and body, and through the relentless cultural conditioning of other selves insisting that we are inextricably located in (and hence responsible for) this particular brain and body. If the self is an illusion of the human brain and body, it’s perhaps understandable that the self perceives itself as located in the brain and body that created it. It is in a sense inseparable from its creator; even before it claims ownership of that brain and body, it realizes it has nowhere else to go.

And everything the illusory self thinks is happening to it is just an experience, a story, an embodied, felt rationalization, and inherently as unreal as the self that invented it. Yet each experience is so compelling the self feels it as real, just as a powerful film makes us feel that its characters and plot are real and we are personally a part of what is happening. The film is just a clever trick, and so is the self.

Someone at the meeting used the word radiance to describe the indescribable everything that just is. I like the term because it’s less mystical, more energetic and less abstract than a lot of other terms often used to describe it. It has a gerund-like sense of amorphousness (somewhere between noun and verb, but not really either) to it, that suits a word trying to “eff the ineffable”. Quantum scientists like Carlo Rovelli and Sean Carroll are starting to describe a universe that “just is”, like an infinite, timeless field of limitless potential. Even if it’s just a metaphor, ascribing radiance to it seems helpful, and a bit poetic.

And as happened with my visit with Tony Parsons in Wales last year, we pondered, as the event drew to a close, why anyone would be compelled (since we have no free will) to come together to discuss such an absurd, hopeless, useless message.

And we wondered, as well, why there aren’t millions coming together to discuss such an awe-inspiring, liberating, elegant, curious, internally-consistent, science-supported message. The possible answers to that are manifold, and endlessly fascinating.

Ottawa-based e-commerce giant Shopify provides the online infrastructure for Ontario, Prince Edward Island, British Columbia and Newfoundland and Labrador’s cannabis sales websites.

According to the company, via BNN Bloomberg, millions of individuals from Canada and the rest of the world have visited the four websites since they went live at 12:01 am in their respective provinces. In that time, the websites have collectively processed approximately 100 orders per minute.

Shopify is also hosting some private retailers’ websites, which have similarly seen a large volume of orders in the provinces that allow private retailers to sell cannabis online. 

Shopify says it was expecting the traffic. Company spokesperson Loren Padelford added that order volumes have been higher than the average Canadian shopping day, but less than Shopify has historically seen on Black Friday.

Source: BNN Bloomberg

The post Shopify-hosted cannabis sales websites taking 100 orders a minute on first day of legal sales appeared first on MobileSyrup.

Canada’s telecom watchdog has released the results of a study undertaken by global market research firm Ipsos to gather public opinions regarding sales practices maintained by Canada’s telecommunications service providers.

The study comes roughly one week in advance of the Canadian Radio-television and Telecommunications Commission’s (CRTC) October 22nd, 2018 unsavoury telecom sales practices hearing.

According to the results of the CRTC’s October 16th, 2018 study, approximately 40 percent of respondents said that they have experienced aggressive or misleading sales practices, while approximately 60 percent of respondents said they’d experienced unsavoury sales practices within the past year.

Approximately 58 percent of respondents said that they were extremely or very concerned about misleading sales practices, while 48 percent said they were concerned about aggressive sales practices.

Ipsos gathered 1,603 results from an online panel survey conducted between August 27, 2018 and September 9th, 2018, as well as 7,075 results from a public survey hosted on the CRTC’s website and a single paper-based survey available for request through the CRTC’s toll-free line.

Ipsos also conducted a number of qualitative studies across Canada, gathering information from seniors, individuals with accessibility needs (categorized as ‘Individuals with disabilities’), official language minority communities and third-language-speaking groups.

Of those surveyed, 55 percent of respondents said that they’ve experienced sales representatives attempting to push products or services that they were not interested in, while 35 percent of respondents said that technical support representatives attempted to sell products or services during a support interaction.

Additionally, 31 percent of respondents said that sales representatives provided false details about telecom products or services during an interaction, while 28 percent of respondents said that they received a rebate or discount offers where specific terms were not disclosed before a purchase had been made.

“When asked to explain their experiences, most comments could be attributed directly to either aggressive or misleading sales practice, while issues with door-to-door sales and poor customer service were also highlighted by some,” reads an excerpt from the report.

What’s interesting is that the CRTC’s study seems to suggest that concerns about telecom companies extend beyond fears of unsavoury sales practices.

Approximately 76 percent of respondents said that they believe that telecom companies “place the pursuit of profit above consumer protection,” while 77 percent said that they believe telecom companies “engage in aggressive or misleading sales practices to pressure more vulnerable people into accepting products or services they do not need.”

Sixty-eight percent of respondents said they believe switching to a provider that doesn’t engage in unsavoury telecom sales practices is the “best way to address aggressive or misleading sales practices.”

On the subject of other carriers, 70 percent of respondents said they were either extremely, very or somewhat concerned about the amount of competition in their specific sector or region.

Of those respondents who have been impacted by aggressive or misleading sales practices, 48 percent said they’d taken “significant steps” to deal with the problem beyond speaking with friends and family.

Only 39 percent of respondents complained to their provider, while only eight percent brought their concerns to the Commission for Complaints for Telecom-Television Services (CCTS).

On the subject of the CCTS, only 30 percent of respondents were aware of that the complaints Commission even existed.

Perhaps as a direct result of the fact that few consumers address their telecom concerns directly, 77 percent of respondents said they want government action “at all levels” to tackle the issue.

Seventy-four percent of respondents said they want the CRTC specifically to address these concerns.

 

Additionally, 84 percent of respondents said they’d support a mandatory code of conduct, 83 percent said they’d support monetary penalties imposed on companies that engage in aggressive or misleading sales practices and 82 percent of respondents supported the public release of a report received by government regarding sales practices.

“Qualitative participants highlighted that these actions would be a means to empower consumers, enable more positive relationships with their telecommunications providers, and engage with the industry as informed consumers,” reads an excerpt from the study.

“They believe that a neutral third party would be best suited to oversee these actions.”

According to the CRTC’s study, Rogers and Bell/Aliant customers were more likely to report having experienced unsavoury telecom sales practices, “either overall or in regards to the specific types of practices presented.”

Videotron customers were more likely to report that they’ve experienced sales representatives attempting to sell products or services that they didn’t want.

Videotron customers were also more likely to report that their unsavoury experiences had taken place within the past year.

Demographic details

Ipsos’s qualitative research lent some insight into the experiences of different groups of Canadians.

Ontario residents were more likely to report experiencing unsavoury telecom sales practices, while Saskatchewan and Manitoba residents were the least likely to report that they’ve experienced unsavoury sales practices.

Rural Canadians were less likely to have personally experienced unsavoury sales practices when compared to their urban counterparts.

Understandably, rural Canadians were more likely than urban Canadians to express concerns about access to telecom services in rural areas.

In terms of age, unsavoury sales practices were more prevalent among individuals younger than 55-years-old, in particular with 18-to-34-year-olds.

More Indigenous respondents said that they’re aware of and have experienced unsavoury sales practices than non-Indigenous respondents.

Indigenous respondents were also less likely than non-Indigenous respondents to support potential remedies for the unsavoury sales practice issue.

Additionally, Canadians who weren’t born in Canada were more tolerant of unsavoury sales practices than Canadians who were born in Canada.

In fact, Canadians who weren’t born in Canada were also less likely to feel that telecom companies care more about profit than people, expressing the belief that unsavoury sales practices are a “normal part of business and that concern about the tactics is exaggerated.”

That being said, “a strong majority” of Canadians not born in Canada were supportive of potential remedies, but still fewer than their counterparts who were born in Canada.

As for language differences, French language-speakers were less likely to express the belief that they’d personally experienced unsavoury sales practices.

Interestingly enough, English language-speakers were more likely to suggest that they’d told friends and family members about unsavoury sales practices.

Finally, individuals who privately submitted responses to the CRTC’s online survey were more likely to be aware of the unsavoury telecom sales issue. They were also more likely to have experienced it personally and were more concerns about unsavoury sales tactics as well.

Once the hearings have concluded, the CRTC will have until February 28th, 2019 to submit a report on unsavoury telecom sales practices in Canada.

Graphs sourced from the CRTC’s October 16th, 2018 report.

Source: CRTC

The post 40% of Canadians have experienced unsavoury telecom sales practices: CRTC appeared first on MobileSyrup.

Are maps “obvious” as to how to read them, or do they need explaining?

Or is the key for visually impaired visitors, with the braille cued by the large, high contrast text?

Essential has laid 30 percent of its employees, the company confirmed in a statement to Bloomberg.

“This has been a difficult decision to make. We are very sorry for the impact on our colleagues who are leaving the company and are doing everything we can to help them with their future careers,” wrote an Essential spokesperson in an email to Bloomberg’s Mark Gurman.

“We are confident that our sharpened product focus will help us deliver a truly game changing consumer product.”

The majority of laid off employees came from the company’s hardware and sales divisions, according to Bloomberg.

The layoffs are the latest in a long line of setbacks for Android creator Andy Rubin’s fledgling startup.

In May 2018, Bloomberg published a report that revealed the company had cancelled work on the Essential Phone 2. Bloomberg also reported that Rubin was exploring a sale of the company.

According to an October 2018 Bloomberg report, in response to its recent hardships, Essential has pivoted to work on a new AI-based phone that users will control primarily through voice. However, there’s no word yet on when the company plans to release that device.

In addition, Essential had planned to release a new audio adapter for the Essential Phone, but the accessory has yet to materialize despite initial promises it would ship before the end of the summer.

Source: Bloomberg

The post Essential has laid off 30 percent of its staff: report appeared first on MobileSyrup.

Apple has updated its privacy microsite in an effort to educate users about the measures the company says it taking to protect personal data across its various products and services — a familiar narrative the tech giant has put forward over the last few months in the wake of the Cambridge Analytica-Facebook scandal.

Further, Apple launched a new system allowing users to request a file outlining all of the personal data they’ve shared with the tech giant.

The updated page reflects Apple’s new rule requiring all new and updated App Store apps to include a specific privacy policy. The change went into effect on October 3rd. Prior to this date, Apple only required apps that accessed personal information to include a privacy policy.

It’s worth noting the privacy features discussed below aren’t necessarily new given that iOS 12 launched back on September 17th, and macOS Mojave dropped on September 24th. Apple’s updated privacy portal highlights the privacy-focused functionality added to the new versions of its operating systems last month.

Both iOS 12 and macOS Mojave, the latest versions of Apple’s mobile and desktop operating systems, feature improved versions of the company’s ‘Intelligent Tracking Prevention’ functionality. Now when a website creates a cookie or asks to store data identifying a user, specific consent is required as long as the user is browsing with Safari.

In the case of macOS Mojave, Apple says it’s more difficult for web-based tracking algorithms to identify a unique device fingerprint — an alternative way of tracking user activity that records information such as device type, display resolution and other factors, that also doesn’t require the use of traditional cookies.

Through iCloud Keychain, Apple also offers automatic password creation via Safari with iOS and macOS, building 1Password-like functionality directly into the operating system. The company’s longstanding commitment to what it calls ‘Differential Privacy’ now includes Memoji, Apple’s playful face-tracking emoji that take advantage of the iPhone X and the iPhone XS’ front-facing Face ID camera module.

Finally, Apple has added various other protections in the latest versions of its operating systems, including asking for user consent with macOS Mojave’s when asking for access to a Mac device’s built-in camera and microphone, including ‘Group FaceTime’ — which hasn’t officially launched yet — as well as Apple’s ‘Screen Time’ iOS 12 activity tracking feature.

Apple also emphasizes that it continues to view privacy as a ‘fundamental human right,’ and that it aims to always ‘minimize its collection of personal data.’

Apple’s CEO Tim Cook will speak at a 2018 Internation Conference of Data Protection and Privacy Commissioners on October 24th in Brussels, Belgium, according to the tech giant.

The tech giant’s new privacy page can be found at apple.com/privacy.

The post Apple updates privacy site to outline changes to iOS 12 and macOS Mojave appeared first on MobileSyrup.

Robin DeRosa, actualham, Nov 01, 2018

---

This is a forward-looking presentation on the sometimes strained relationship between libraries and OER. " Moving to OER is about committing to learning environments that respect the realities of place, that engage with the contexts for learning, that challenge barriers that try to co-opt public channels for private gain, and that see learning as a fundamentally infinite process that benefits from human interaction."

Web: [Direct Link] [This Post]

[Slides][Audio] This special briefing explores personal learning as the future of learning, explores why it's important, the tools which enable personal learning and the significant potential of personal learning as a key to life-long learning and the skills agenda. Online Learning 2018, Toronto, Ontario (Lecture) Oct 17, 2018 [Comment]

Tony Hirst, OUseful Info, Nov 01, 2018

---

If it's just machines talking to machines then I don' see why I should be interested, but of corse the gist of the post revolves around whether these machines are trying to influence us. This may sound like a trivial question - and I like Tony Hirst's examples - but it raises the deeper issue of what constitutes (if anything does) machine autonomy. Because someone, somewhere, created the algorithms that automatically create headlines or autofill forms. At a certain important level it's people influencing people, but those people are well-hidden by the machines.

Web: [Direct Link] [This Post]

People have praised Google’s Pixel line of phones for its superior camera tech. The Pixel 3 and 3 XL bring even more enhancements, Super Res Zoom being one of the more interesting ones.

When Google first announced the feature, it said the camera would rely on the movement of your hands to make zoomed photographs look better. While that idea seems counterintuitive — how can my shaky hands make my photo better? — the results of Super Res Zoom speak for themselves.

The search giant claims that 2x zoom using its digital system is comparable to the 2x optical lens systems used on competing phones. Impressively, the claim is accurate too.

Thankfully the company has posted an in-depth breakdown of how Super Res Zoom works on its AI blog so we can see how it works.

To understand Super Res Zoom, you need to understand demosaicing

Demosaicing is a process that fills in colour information that’s missing from an image. Typical consumer and smartphone cameras use sensors designed to measure the intensity of light, not its colour.

To capture colour, cameras use a colour filter array placed in front of the sensor. This array makes each pixel capture only one colour (red, green or blue). Cameras usually use a Bayer pattern (shown above) for the array.

Demosaicing makes a best guess at the missing colour information based on the colour information from surrounding pixels. According to Google, about two-thirds of an RGB digital picture is a reconstruction.

Using the Bayer array to your advantage

Part of the reason that digital zoom doesn’t look great is this demosaicing feature. Digital zoom essentially crops the picture and relies on the demosaicing process to fill in more colour information based on less surrounding information from the sensor.

However, by combining burst photography with hand motion, Google created a system that can gather more colour information.

Essentially, the system merges a burst of low-resolution images onto a high-resolution grid. You can see a diagram above that shows the idealized algorithmic process.

In the diagram, the camera captures four frames, three of which are moved precisely one pixel horizontally, vertically and both directions.

This fills in all the ‘holes’ in the Bayer array, reducing or eliminating the need for demosaicing.

Interestingly, the Pixel 3 will jiggle its sensor if there isn’t enough movement for Super Res Zoom. You can see this in effect if you stabilize the phone and go to the maximum 7x zoom.

If Super Res Zoom doesn’t detect enough hand shake to collect data to create a zoomed image, it will move the lens on its own to gather more data. Look at it wiggle.

(gif by @billiamjoel ) pic.twitter.com/ZwWfcTzZfA

— Dieter Bohn (@backlon) October 14, 2018

Like everything, it isn’t that simple

Unfortunately, there were a lot of hurdles that Google had to leap to make Super Res Zoom work.

For one, things tend to move around, so the algorithm also has to contend with motion outside of the camera. Movement can also increase information density in one area of the photo. Since Super Res Zoom relies on interpolating data to fill in the blanks, too much information in one spot can mess with that process.

Additionally, Google says that a single image from a burst photograph can be noisy, even in good lighting conditions. The algorithm had to work correctly despite the noise.

Google has solutions

Google managed to solve some of these problems with some smart work in the algorithm.

One example is that Google’s algorithm uses edge detection when merging images. When the algorithm blends pixels, it does so along an edge instead of across it. This allows Google to strike a balance between noise reduction and enhanced details.

Furthermore, the company developed a ‘robustness’ model to detect and mitigate alignment errors when merging images. The model will only merge information into other frames if it’s sure it’s found the correct place to merge it. Thanks to this model, Super Res Zoom photos don’t have artifacts like ‘ghosting’ and motion blur.

Overall, it’s a very robust system that churns out surprisingly good results. Google’s Pixel 3 solves the difficulty of bad digital zoom.

If you want to learn more about the process, you can check out the Google blog here. Also, the company posted a Google Photos album featuring many uncropped Super Res Zoom images. They are seriously impressive (see an example below).

Source: Google Via: Android Police

The post This is how Google’s Super Res Zoom feature works on the Pixel 3 appeared first on MobileSyrup.