This is one of the great mysteries of the 20th century, and perhaps one of the most enigmatic. A dying old man, a former general who made money in oil and who had daughters far too late, believes he is being blackmailed. His elder daughter is working on her third divorce, and the general rather liked son-in-law #3, a rakish mobster whose thorough unsuitability rather appealed to the general’s humor. A plot-driven adventure that, characteristically for Chandler, pays remarkably little attention to the details of plot; everyone cares deeply what’s going on right now and they behave as if everything makes sense, and we go right along. A brilliant portrait of the America that bred Trump.
A skeptical but intelligent survey of postmodern thought. Butler assumes that postmodernism is over and concludes that, overall, it lost its argument with liberal realism while teaching important lessons about gender, identity, and power. He is, interesting, quite sympathetic to postmodern literature while clearly well out of sympathy with much postmodern art; I’d have liked a bit more discussion of architecture and (especially) cinema, where Louis Menand’s article on Pauline Kael seems very much at odds with Butler’s emphasis on politics rather than anti-formalism.
The Mass. Dems had their convention this weekend. Ed Markey told us again that “Democrats don’t agonize, they organize.” This was always untrue, but this year it’s preposterous.
Hint to Democrats: when you’ve got an audience of 5000, committed and active and almost all of whom have paid good money and gotten elected in order to be delegates, respect them enough to tell them something new, fresh, and important. And no doubt it’s a dandy thing to represent Worcester, but really, once is enough.
While macOS High Sierra brought relatively small changes to the Mac’s operating system, WWDC featured big news for the Mac: new hardware.
Headlined by the iMac Pro, over half of all Mac models received updates, ranging from speed bumps to a full-on introduction of a new desktop model. Although WWDC was anticipated as an iPad-heavy presentation – and delivered on that front – here’s why it was larger than life for the Mac as well.
iMac Pro
Mac fans discouraged by Apple’s current offerings to the pro market will take solace in today’s biggest Mac announcement: the iMac Pro.
Encased in a space gray housing, the iMac Pro retains the same form factor as its recent iMac predecessors while offering massive improvements to the spec sheet. Numbers like 8-, 10-, or 18-core Xeon processors or 11 teraflops of single precision and 22 teraflops of half precision jump out immediately, and RAM up to 128GB and SSDs up to 4TB are sure to draw pro users' attention to the iMac Pro.
Apple’s biggest push with the iMac Pro, though, came by detailing what it can do. Armed with an all-new Radeon Pro Vega graphics chip offering three times faster performance over any other iMac GPU, Apple touted the desktop as a computer built for video editing, virtual reality, and “gameplay at max settings.”
Further improvements include an enhanced speaker system, a new thermal architecture, and the inclusion of four Thunderbolt 3 ports. New accessories also debuted alongside the iMac Pro, featuring space gray versions of the Magic Keyboard (now outfitted with a numeric keypad), Magic Trackpad 2, and Magic Mouse 2.
The iMac Pro will start at a base price of $4,999, and will rise accordingly based on the configuration of the model. According to Apple, we can expect to see the iMac Pro go on sale in December.
iMac, MacBook, and MacBook Pro
Kaby Lake was the chip of the day for Apple, appearing in the latest versions of the iMac, MacBook, and MacBook Pro. With processor speeds up to 4.2 GHz, 1.3 GHz, and 3.5 GHz, all three Mac models received considerable speed bumps through the new processors.
On the iMac side, the refresh also came with more powerful graphics from a Radeon Pro 500-Series chip and up to 8 GB of vRAM. With faster SSDs also coming to the iMac and MacBook and a screen upgrade to 500 nits and 1 billion colors for the iMac, the Mac hardware changes were considerable despite the lack of any external redesigns.
Finally, both the iMac and MacBook Pro saw entry-level price drops to $1,299 for the 4K iMac and 13-inch MacBook Pro without Touch Bar.
The most exciting announcement regarding the iMac and MacBook Pro variations, at least to me, is the price drop, allowing consumers better access to more power. With discounts coming seasonally at retailers, these computers will become good pickups for college students in the fall.
MacBook Air
Continuing its ever-so-slow death, the MacBook Air today received a minor upgrade to a 1.8 GHz processor, an update very few people likely asked for and one that doesn’t make much sense in the grand scheme of Apple’s Mac product line. However, those who will purchase the MacBook Air may, I suppose, appreciate the bump.
Wrap-Up
I can't say that I expected this kind of day for the Mac, but the improvements shown at the keynote display Apple's commitment to the Mac platform despite the aging Mac Pro. In fact, Apple seems to be pushing the Mac lines to new heights, offering models that can reach both the average consumer and the professional who desires a powerful workstation. By making moves in the VR space and laying out the landscape for the future of the Mac, Apple's announcements today checked all the right boxes.
While it’s been rumoured for a number of months now that Apple is interested in the augmented reality space, at WWDC today we got our first glimpse of the tech giant’s initial step into AR.
To some extent, Apple is playing catch-up with Google, which has already launched its Tango augmented reality platform — though Tango devices are still difficult to come by. During Apple’s WWDC keynote, however, the company’s senior vice president of software engineering, Craig Federighi, revealed ARKit and boasted that it will be available across the company’s iOS ecosystem, creating “the largest AR platform in the world.”
During the hands-on media-only portion of the keynote following the main presentation, I was able to quickly go hands-on with ARKit. Bearing a striking resemblance to Google’s Tango platform, I placed a lamp, vase and various other objects on a surface, and then was able to move the new 10.5-inch iPad Pro’s camera around and look at it from different angles. While I’ve only spent a brief period of time with Tango, I’d say the experience is very comparable to Apple’s ARKit.
I was also shown an AR version of the well-known Star Wars holographic chess game, complete with a surprisingly realistic version of Jabba The Hut.
On stage Federighi explained how Pokémon Go’s object recognition will improve thanks to ARKit, allowing Pokéballs to bounce across surfaces, rather than just floating. The creative lead also showed off a more complex augmented reality experience created by Peter Jackson’s Wingnut AR studio, which utilizes Unity and SceneKit in conjunction with ARKit and is set to launch “later this year.” Unfortunately, this particular demo was not available in the hands-on area.
Of course, like all of Apple’s development kit utilities, the tech giant’s new ARKit will only be a success if the company manages to convince app developers to get on board with it. Google seems to have managed to attract a small amount of developers to its AR platform and given Apple’s vibrant app ecosystem, it’s likely the Cupertino-based company will do the same.
Apple has announced deeper Apple Pencil integration on iOS 11 for iPad.
The updated Markup feature allows iPad users to draw all over almost anything on their iPads, including the Notes app.
IOS 11 also brings a document scanner to the Notes app.
Using the iPad camera, users can take photos of physical documents, digitize those documents, preserve all of their formatting, and manipulate the digital documents using Apple Pencil.
The document scanner and deeper Apple Pencil integration will launch with iOS 11 later this year.
Apple today announced a standalone speaker called HomePod that has a strong focus on music, which Apple hopes will “reinvent music” in the home.
It comes in white and black, is just under seven inches tall and covered in a mesh fabric. It has a seven-array tweeter pack, each with an individual driver, all controlled by an A8 chip. It also features spatial awareness to tune sound to its environment.
The speaker is controlled by voice AI, like Google Home and Amazon Alexa. It features six microphones, and users can say ‘Hey Siri’ to command the AI, which is primarily intelligent on the subject of music.
For instance, Apple says it can handle complex music-related questions like asking who the individual musicians from a song are, or other obscure music trivia.
But while HomePod’s Siri is mainly a ‘musicologist,’ it can also deal with commands regarding podcasts, weather, sports and HomeKit smarthome devices. Additionally, users can send iMessages through Siri on HomePod.
The company says it is “designed to work with an Apple Music subscription,” presumably meaning there’s no integration for third-party streaming apps like Spotify.
Apple says it is coming “later this year” to the U.S., U.K. and Australia, while it will arrive elsewhere at some point in 2018. The HomePod will be available for $349 USD (about $470 CAD).
The City of New Westminster has an exciting opportunity for a Public Engagement Coordinator. With the recent adoption of a new Public Engagement Strategy, we are seeking a dynamic and creative individual who will be responsible for coordinating New Westminster’s public engagement initiatives and working with other City staff to enhance outreach activities.
Reporting to the Manager of Communications and Economic Development, you will use your skills working closely with staff to create a culture of engagement and will develop mechanisms to assist public stakeholders in understanding key city issues and priorities. You will also assist City departments with the strategic planning and evaluation of major engagement initiatives.
Your responsibilities include organizing and coordinating public engagement and community outreach programs; reviewing and evaluating engagement systems and activities; and providing consultation, training and assistance to internal staff on implementing engagement tools. You are a self-starter who can exercise considerable independence of judgment and action in the creative aspects of your work.
If this sounds like the perfect fit for your passion, talent and skills, we would love to hear from you
Homepod and Airplay 2 are an immediate threat to the Sonos business in pure Apple households. It combines Siri smarts with Homekit integration, streams directly from Apple Music, it looks quite capable in the sound department and it comes at a low price. $349 is a PLAY:3 plus an Echo Dot and I would be surprised if it did not sound better. We will see how well Apple does multi-room, but I give them the benefit of the doubt. Available first in the US it will come to Europe next year.
iOS 11 is a fantastic update for iPads. It brings many of the Windows 10 features around inking and multitasking to the iPad. You also finally get file management and drag&drop. This will make the iPad much more capable as your main computer. So far I have advised against that, but I will reevaluate my position once iOS 11 ships in the fall. Adding a bigger screen to the smaller iPad Pro is also a plus and it will make it even more popular. With a 64 GB iPad Pro starting at $649 it may give the iPad line a much needed boost.
New hardware for iMac, MacBook Pro and a screaming fast iMac Pro, that is all very welcome news, unless, well you just bought a new MacBook Pro. 7th gen Intel chips were to be expected but much faster SSDs and lower entry level prices were not.
There were a whole lot of things in iOS 11 and macOS High Sierra targeted at developers that Hairforce One rattled through. I need to watch all of that a couple of times until I fully understand.
watchOS 4 was mostly meh. New watchfaces, a new timeline, yeah. I bet the really cool stuff is invisible like the full Bluetooth stack that lets the watch interface other equipment. How about that rumored non-invasive glucose monitor? When that becomes available it will take over the world for all diabetes patients.
Amazone Prime video coming to the Apple TV. That's about time.
iOS 11 on iPad - that was the most interesting part for me. Homepod will be interesting next year, but it won't have the breadth and depth of Sonos. No TV surround, limited to Apple Music, no Android support. But hey, if you live in Apple land, you will want this for sure.
As always, Apple’s WWDC keynote address was filled with a barrage of customer satisfaction figures, performance improvements, and more. Here are some of the most important numbers from today’s WWDC keynote.
Developers
Apple now has 16 million registered developers, adding 3 million “last year alone.”
WWDC 2017 has 5,300 total attendees from 75 countries represented.
Apple Watch
watchOS 4 brings 3 new types of Apple Watch faces: Toy Story, Kaleidoscope, and Siri.
macOS High Sierra
Safari is now 80% faster than Chrome in modern JavaScript performance.
Mail content now takes up 35% less disk space.
iMacs, MacBooks, and MacBook Pros
The updated iMac screens now reach 500 nits of brightness.
The new iMacs have 43% brighter screens while displaying one billion colors.
The base model of the 21.5” iMac received an 80% graphics boost.
The latest 4K 21.5” iMac now comes with 3x faster graphics.
The 5K 27” iMac now sports up to 5.5 teraflops of graphics computing power.
iOS
iOS has a 96% customer satisfaction rating, with an 86% iOS 10 install rate.
50% of U.S. retailers will accept Apple Pay by the end of the year.
Siri now supports 21 languages and 36 countries.
iOS users take 1 trillion photos per year in the Camera app.
Apple Music now has 27 million paid subscribers.
The App Store is visited by 500 million users weekly, boasts 180 billion app downloads total in its history, and has paid $70 billion to developers to date.
iPad Pro
The 10.5” iPad Pro screen is 20% larger than the 9.7” iPad Pro's and the device weighs 1 pound.
The new 10.5” and 12.9" iPad Pros reach a brightness of 600 nits and have a 120hz display refresh rate.
Apple Pencil paired with the new iPad Pros has cut latency to 20ms.
The 10.5” iPad Pro sports a 6-core CPU and a 12-core GPU, leading to 30% faster CPU performance and 40% faster graphics performance.
The 10.5” iPad Pro has 10-hour battery life.
HomePod
HomePod is under 7” tall.
HomePod has a 6 microphone system for “Hey Siri” listening.
Apple Music brings 40 million songs to your living room.
Apple is entering the smart speaker space, and it's doing that with a new product launching this December called HomePod.
Introduced at the end of today's WWDC keynote, HomePod is a Siri-equipped smart speaker that specializes in music. Rather than solely competing with products like the Amazon Echo and Google Home, Apple is positioning HomePod as a hybrid product that does more. It contains many of the same capabilities of those assistant-equipped speakers, but adds one more thing: high quality audio. This makes it not only a competitor to the Echo and Home, but also to home audio systems like those offered by Sonos and Bose. This latter market is where Apple has so far focused its marketing, as reflected by the title of its introductory press release: "HomePod reinvents music in the home."
Unsurprisingly, the HomePod is designed to work best with Apple Music. This support is highlighted by Siri's expanded knowledge in the domain of music. Users will be able to ask questions like, "Who's the drummer in this?" or "Who's singing?" There is more flexibility in Apple Music-related commands as well, allowing you to tell Siri, "Play something new" or "Add this to my workout playlist."
In addition to the focus on Apple Music, Phil Schiller highlighted a number of other areas that Siri would be equipped to handle on the HomePod, as seen below. These include the obvious things like HomeKit device control and general knowledge inquiries, as well as fresh Siri domains like News.
Hardware-wise, HomePod is powered by an A8 chip, a six-microphone array, seven beam-forming tweeters, and a 4-inch woofer. These combine to create a powerful audio mix meant to fill a room. A HomePod is spatially aware, meaning it can analyze the acoustics of a room and adjust sound based on its location in that room. It also includes new technology like Apple's AirPlay 2 protocol, which allows multi-speaker support that will enable multiple HomePod devices to wirelessly communicate with each other.
As with products like the Amazon Echo, the HomePod's primary interface method is through voice. It does not contain a screen. But there are some basic options for touch input as well. By tapping the top of the HomePod, you can play, pause, or adjust the volume of whatever's playing. The top of the HomePod also lights up to display an LED waveform while you're talking to it, similar to the way Siri interactions animate on other Apple devices.
When the HomePod is released this December, it will be available in both White and Space Grey finishes. It will launch first in the US, UK, and Australia, with more countries to follow in 2018.
Apple has a short product video for its new product, available for viewing below.
Today at WWDC, we’re excited to announce the next step in our collaboration with Apple with the integration of Dropbox into the Files app for iOS 11.
iOS users have been requesting better file management on iPhone and iPad for a long time. The new Files app, coming later this year, does just that, letting you more easily manage and access files in your Dropbox throughout iOS 11. Much like macOS Finder, Files will give you an easy way to browse, open, edit, move, rename, upload, create folders and download files stored in Dropbox with your iOS device.
More than that, though, it will extend file capabilities system-wide. You’ll be able to access files in your Dropbox account from third-party apps just as if they were stored on your iPhone or iPad. This integration will even work with Dropbox-specific features for teams, like commenting and viewer info, letting you collaborate on files from any app that supports file browsing.
Dropbox and Apple share a commitment to simplicity, attention to detail, and focus on the user. This integration will help us create a more seamless, elegant Dropbox experience. We’re excited to have the latest, deeply-integrated Dropbox functionality in iOS 11 join our other powerful integrations with tools from Adobe, Facebook, and Microsoft. Be sure to check back here for more info on Files support when iOS 11 launches later this year.
Apple’s Worldwide Developers Conference (WWDC) keynote has officially wrapped up in San Jose, California. During this afternoon’s presentation, the Cupertino-based tech giant revealed many additions to its iOS, iPad and Mac family of devices, among other announcements.
There was a lot to keep up with, so keep on scrolling for a comprehensive list of everything that Apple showed off during the keynote.
How cool is this? You can uninstall a program right from the Start menu in Windows 10. That’s a lot more efficient than the method most people know: burrowing into the Control Panel or the Settings app and fumbling around.
Just right-click the name of the app you want to remove; from the shortcut menu, choose Uninstall. In the dialog box that appears, confirm that yes, you really want do go through with this.
Note: You can’t uninstall apps that came with Windows 10 this way — only stuff you’ve added. Microsoft has its standards, after all.
David Pogue, tech columnist for Yahoo Finance, welcomes nontoxic comments in the comments section below. On the web, he’s davidpogue.com. On Twitter, he’s @pogue. On email, he’s poguester@yahoo.com. You can read all his articles here, or you can sign up to get his columns by email.
Update: The previous version of this post showed performance data from ARES-6 version 1.0. Version 1.0 had a bug where the score for the Worst 4 Iterations was actually using the first 4 iterations. We have fixed the bug and updated the benchmark to version 1.0.1. The performance results shown in this post now use ARES-6 version 1.0.1, which contains the fix.
ES2015 (also known as ES6), the version of the JavaScript specification ratified in 2015, is a huge improvement to the language’s expressive power thanks to features like classes, for-of, destructuring, spread, tail calls, and much more. But powerful language features come at a high cost for language implementers. Prior to ES6, WebKit had spent years optimizing the idioms that arise in ES3 and ES5 code. ES6 requires completely new compiler and runtime features in order to get the same level of performance that we have with ES5.
WebKit’s JavaScript implementation, called JSC (JavaScriptCore), implements all of ES6. ES6 features were implemented to be fast from the start, though we only had microbenchmarks to measure the performance of those features at the time. While it was initially helpful to optimize for our own microbenchmarks and microbenchmark suites like six-speed, to truly tune our engine for ES6, we needed a more comprehensive benchmark suite. It’s hard to optimize new language features without knowing how those features will be used. Since we love programming, and ES6 has many fun new language features to program with, we developed our own ES6 benchmark suite. This post describes the development of our first ES6 benchmark, which we call ARES-6. We used ARES–6 to drive significant optimization efforts in JSC, and this post describes three of them: high throughput generators, a new Map/Set implementation, and phantom spread. The post concludes with an analysis of performance data to show how JSC’s performance compares to other ES6 implementations.
ARES-6 Benchmark
The suite consists of two subtests we wrote in ES6 ourselves, and two subtests that we imported that use ES6. The first subtest, named Air, is an ES6 port of the WebKit B3 JIT‘s Air::allocateStack phase. The second subtest, named Basic, is an ES6 implementation of the ECMA-55 BASIC standard using generators. The third subtest, named Babylon, is an import of Babel’s JavaScript parser. The fourth subtest, named ML, is an import of the feedforward neural network library from the mljs machine learning framework. ARES-6 runs the Air, Basic, Babylon, and ML benchmarks multiple times to gather lots of data about how the browser starts up, warms up, and janks up. This section describes the four benchmarks and ARES-6’s benchmark running methodology.
Air
Air is an ES6 reimplementation of JSC’s allocateStack compiler phase, along with all of Assembly Intermediate Representation needed to run that phase. Air tries to faithfully use new features like arrow functions, classes, for-of, and Map/Set, among others. Air doesn’t avoid any features out of fear that they might be slow, in the hope that we might learn how to make those features fast by looking at how Air and other benchmarks use them.
At the time that Air was written, most JavaScript benchmarks used ES5 or older versions of the language. ES6 testing mostly relied on microbenchmarks or conversions of existing tests to ES6. We use larger benchmarks to avoid over-optimizing for small pieces of code. We also avoid changing existing benchmarks because that approach has no limiting principle: if it’s OK to change a benchmark to use a feature, does that mean we can also change it to remove the use of a feature we don’t like? We feel that one of the best ways to avoid falling into the trap of creating benchmarks that only reinforce what some JS engine is already good at is to create a new benchmark from first principles.
We only recently completed our new JavaScript compiler, named B3. B3’s backend, named Air, is very CPU-intensive and uses a combination of object-oriented and functional idioms in C++. Additionally, it relies heavily on high speed maps and sets. It goes so far as to use customized map/set implementations – even more so than the rest of WebKit. This makes Air a great candidate for ES6 benchmarking. The Air benchmark in ARES-6 is a faithful ES6 implementation of JSC’s Air. It pulls no punches: just as the original C++ Air was written with expressiveness as a top priority, ES6 Air is liberal in its use of modern ES6 idioms whenever this helps make the code more readable. Unlike the original C++ Air, ES6 Air doesn’t exploit a deep understanding of compilers to make the code easy to compile.
Design
Air runs one of the more computationally expensive C++ Air phases, Air::allocateStack(). It turns abstract stack references into concrete stack references, by selecting how to lay out stack slots in the stack frame. This requires liveness analysis and an interference graph.
Air relies on three major ES6 features more so than most of the others:
Arrow functions. Like the C++ version with lambdas, Air uses a functional style of iterating most non-trivial data-structures. This is because the functional style allows the callbacks to mutate the data being iterated: if the callback returns a non-null value, forEachArg() will replace the argument with that value. This would not have been possible with for-of. Air’s use of forEachArg() and arrow functions usually looks like this:
inst.forEachArg((arg, role, type, width) => ...)
For-of. Many Air data structures are amenable to for-of iteration. While the innermost loops tend to use functional iteration, pretty much all of the outer logic uses for-of heavily. For example:
for (let block of code) // Iterate over the basic blocks in a program
for (let inst of block) // Iterate over the instructions in a block
...
Map/Set. The liveness analysis in Air::allocateStack() relies on maps and sets. For example, we use a liveAtHead map that is keyed by basic block. Its values are sets of live stack slots. This is a relatively crude way of doing liveness, but it is exactly how the original Air::LivenessAnalysis worked. So we view it as being quite faithful to how a sensible programmer might use Map and Set.
Air also uses some other ES6 features. For example, it makes light use of a Proxy. It makes extensive use of classes, let/const, and Symbols. Symbols are used as enumeration elements, and so, they frequently show up as cases in switch statements.
The workflow of an Air run is pretty simple: we do 200 runs of allocateStack on four IR payloads.
Each IR payload is a large piece of ES6 code that constructs an Air Code object, complete with basic blocks, temporaries, stack slots, and instructions. These payloads are generated by running the Air::dumpAsJS() phase. This is a phase we wrote in the C++ version of Air that will generate JS code that builds an IR payload. Just prior to running the C++ allocateStack phase, we perform Air::dumpAsJS() to capture the payload. The four payloads we generate are for the hottest functions in four other major JS benchmarks:
Kraken/imaging-gaussian-blur, the gaussianBlur function.
Octane/Typescript, the scanIdentifier function.
Air (yes, it’s self referential), an anonymous closure identified by our profiler as ACLj8C.
These payloads allow Air to precisely replay allocateStack on those actual functions.
Air validates its results. We added a Code hashing capability to both the C++ Air and ES6 Air, and we assert each payload looks identical after allocateStack to what it would have looked like after the original C++ allocateStack. We also validate that the payloads hash properly before allcoateStack, to help catch bugs during payload initialization. We have not measured how long hashing takes, but it’s an O(N) operation, while allocateStack is closer to O(N^2). We suspect that barring some engine pathologies, hashing should be much faster than allocateStack, and allocateStack should be where the bulk of time is spent.
Summary
At the time that Air was written, we weren’t happy with the ES6 benchmarks that were available to us. Air makes extensive use of ES6 features in the hope that we can learn about possible optimization strategies by looking at this and other benchmarks.
Air does not use generators at all. We almost used them for forEachArg iteration, but it would have been a very unusual use of generators because Air’s forEach functions are more like map than for-of. The whole point is to allow the caller to mutate entries. We thought that functional iteration was more natural for this case than for-of and generators. But this led us to wonder: how would we use generators?
Basic
Web programming requires reasoning about asynchrony. But back when some of us first learned to program with the BASIC programming language, we didn’t have to worry about that: if you wanted input from the user, you said INPUT and the program would block until the user typed things. In a sense, this is what generators are about: when you say yield, your code blocks until some other stuff happens.
Basic is an ES6 implementation of ECMA-55 BASIC. It implements the interpreter as a recursive abstract syntax tree (AST) walk, where the recursive functions are generators so that they can yield when they encounter BASIC’s INPUT command. The lexer is also written as a generator. Basic tests multiple styles of generators, including functions with multiple yield points and recursive yield* calls.
Lexers are usually written as a lex function that maintains some state and returns the next token whenever you call it. Basic uses a generator to implement lex, so that it can use local variables for all of its state.
Basic’s lexer is a generator function with multiple nested functions inside it. It contains eight uses of yield, none of which are recursive.
AST Walk
Walking the AST is an easy way to implement an interpreter and this was a natural choice for Basic. In such a scheme, the program is represented as a tree, and each node has code associated with it that may recursively invoke sub-nodes in the tree. Basic uses plain object literals to create nodes. For example:
This code in the parser creates an AST node whose evaluation function is Basic.NumberPow. Were it not for INPUT, Basic could use ordinary functions for all of the AST. But INPUT requires blocking; so, we implement that with yield. This means that all of the statement-level AST nodes use generators. Those generators may call each other recursively using yield*.
The AST walk interpreter contains 18 generator functions with two calls to yield (in INPUT and PRINT) and one call to yield* (in Basic.Program).
Workloads
Each Basic benchmark iteration runs five simple Basic programs:
Hello world!
Print numbers 1..10.
Print a random number.
Print random numbers until 100 is printed.
Find all prime numbers from 2 to 1999.
The interpreter uses a fixed seed, so the random parts always behave the same way. The Basic benchmark runs 200 iterations.
Summary
We wrote Basic because we wanted to see what an aggressive attempt at using generators looks like. Prior to Basic, all we had were microbenchmarks, which we feared would focus our optimization efforts only on the easy cases. Basic uses generators in some non-obvious ways, like having multiple generator functions, many yield points, and recursive generator calls. Basic also uses for-of, classes, Map, and WeakMap.
Babylon and ML
It is important to us that ARES-6 consists both of tests we wrote, and tests we imported. Babylon and ML are two tests we imported with minor modifications to make them run in the browser without Node.js style modules or ES6 modules. (The reason for not including tests with ES6 modules is that at the time of writing this, <script type="module"> is not on by default in all major browsers.) Writing new tests for ARES-6 is important because it allows us to use ES6 in interesting and sophisticated ways. Importing programs we didn’t write is also imperative for performance analysis because it ensures that we measure the performance of interesting programs already using ES6 out in the wild.
Babylon is an interesting test for ARES-6 because it makes light use of classes. We think that many people will dip their toes into ES6 by adopting classes since many ES5 programs are written in ways that lead to an easy translation to classes. We’ve seen this firsthand in the WebKit project when Web Inspector moved all their ES5 pseudo-classes to use ES6 class syntax. You can browse the Babylon source in ARES-6 here. The Babylon benchmark runs 200 iterations where each iteration consists of parsing four JS programs.
Air, Basic and Babylon each run for 200 iterations, and ML runs for 60 iterations. Each iteration does the same kind of work. We simulate page reload before the first of those iterations, to minimize the chances that the code will benefit from JIT optimizations at the beginning of the first iteration. ARES-6 analyzes these four benchmarks in three different ways:
Start-up performance. We want ES6 code to run fast right from the start, even if our JITs haven’t had a chance to perform optimizations yet. ARES-6 reports a First Iteration score that is just the execution time of the first of the 60 or 200 iterations.
Worst-case performance. JavaScript engines have a lot of different kinds of jank. The GC, JIT, and various adaptive optimizations all run the risk of causing programs to sometimes run for much longer than the norm. We don’t want our ES6 optimizations to introduce new kinds of jank. ARES-6 reports a Worst 4 Iterations score that is the average of the execution times of the worst 4 of the 60 or 200 iterations, excluding the first iteration which was used for measuring start-up performance.
Throughput. If you write some ES6 code and it runs for long enough, then it should eventually benefit from all of our optimizations. ARES-6 reports an Average score that is the average execution time of all iterations excluding the first.
Each repetition of ARES-6 yields 3 scores (measured in milliseconds): First Iteration, Worst 4 Iterations, and Average, for each of the 4 subtests: Air, Basic, Babylon, and ML, for a total of 12 scores. The geometric mean of all 12 scores is the Overall score for the repetition. ARES-6 runs 6 repetitions, and reports the averages of each of these 13 scores along with their 95% confidence intervals. Since these scores are measures of execution time, lower scores are better because they mean that the benchmark completed in less time.
Optimizations
We built ARES-6 so that we could have benchmarks with which to tune our ES6 implementation. ARES-6 was built specifically to allow us to study the impact of new language features on our engine. This section describes three areas where we made significant changes to JavaScriptCore in order to improve our score on ARES-6. We revamped our generator implementation to give generator functions full access to our optimizing JITs. We rewrote our Map/Set implementation so that our JIT compiler can inline Map/Set lookups. Finally, we added significant new escape analysis functionality to eliminate the object allocation of the rest parameter when used with the spread operator.
High-Throughput Generators
The performance of ES6 generators is critical to the overall performance of JavaScript engines. We expect generators to be frequently used as ES6 adoption increases. Generators are a language-supported way to suspend and resume an execution context. They can be used to implement value streams and custom iterators, and are the basis of ES2017’s async and await, which streamlines the notoriously tricky asynchronous Promise programming model into the direct style programming model. To be performant, it was an a priori goal that our redesigned generator implementation had a sound and simple compilation strategy in all of our JIT tiers.
A generator must suspend and resume the execution context at the point of a yield expression. To do this, JSC needs to save and restore its execution state: the instruction pointer and the current stack frame. While we need to save the logical JavaScript instruction pointer to resume execution at the appropriate point in the program, the machine’s instruction pointer may change. If the function is compiled in upper JIT tiers (like baseline, DFG, and FTL), we must select the code compiled in the best tier when resuming. In addition, the instruction pointer may be invalidated if the compiled code is deoptimized.
JSC’s bytecode is a 3AC-style (three-address code) IR (intermediate representation) that operates over virtual registers. The bytecode is allowed an effectively “infinite” number of registers, and the stack frame comprises slots to store each register. In practice, the number of virtual registers used is small. The key insight into our generator implementation is that it is a transformation over JSC’s bytecode. This completely hides the complexity of generators from the rest of the engine. The phases prior to bytecode generatorification (parsing, bytecode generation from the AST) are allowed to view yield as if it were a function call — about the easiest kind of thing for those phases to do. Best of all, the phases after generatorification do not have to know anything about generators. That’s a fantastic outcome, since we already have a massive interpreter and JIT compiler infrastructure that consumes this bytecode.
When generating the original bytecode, JSC’s bytecode compiler treats a generator mostly as if it were a program with normal control flow, where each “yield” point is simply an expression that takes arguments, and results in a value. However, this is not how yield is implemented at a machine level. To transform this initial form of bytecode into a version that does proper state restoration, we rewrite the generator’s bytecode to turn the function into a state machine.
To properly restore the instruction pointer at yield points, our bytecode transformation inserts a switch statement at the top of each generator function. It performs a switch over an integer that represents where in the program the generator should resume when called. Secondly, we must have a way to restore each virtual register at each yield point. It turns out that JSC already has a mechanism for doing exactly this. We turned this problem into a problem of converting each bytecode virtual register in the original bytecode into a closure variable in JSC’s environment record data structure. Each transformed generator allocates a closure to store all generator state. Every yield point saves each live virtual register into the closure, and every resume point restores each live virtual register from the closure.
Because this bytecode transformation changes the program only by adding closures and a switch statement, this approach trivially meets our goal of being compilable in our optimizing compiler tiers. JSC’s optimizing compilers already do a good job at optimizing switch statements and closure variables. The generator’s dispatch gets all of JSC’s switch lowering optimizations just by virtue of using the switch bytecode. This includes our B3 JIT’s excellent switch lowering optimization, and less aggressive versions of that same optimization in lower JIT tiers and in the interpreter. The DFG also has numerous optimizations for closures. This includes inferring types of closure variables, optimizing loads and stores to closures down to a single instruction in most cases, and properly modeling the aliasing effects of closure accesses. We get these benefits without introducing new constructs into the optimizing compiler.
Example
Let’s walk through an example of the bytecode transformation for an example JavaScript generator function:
function *generator()
{
var temp = 20;
var result = yield 42;
return result + temp;
}
JSC generates the bytecode sequence shown in the following figure, which represents the control flow graph.
When the AST-to-bytecode compiler sees a yield expression, it just emits the special op_yield bytecode operation. This opcode is a macro. It’s not recognized by any of our execution engines. But it has well-understood semantics, which allows us to treat it as bytecode syntactic sugar for closures and switches.
Desugaring is performed by the generatorification bytecode phase. The figure above explains how generatorification works. Generatorification rewrites the bytecode so that there are no more op_yield statements and the resulting function selects which code to execute using a switch statement. Closure-style property access bytecodes are used to save/restore state around where the op_yield statements used to be.
Previously, JSC bytecode was immutable. It was used to carry information from the bytecode generator, which wrote bytecode as a byproduct of walking the AST, to the compilers, which would consume it to create some other byproduct (either machine code or some other compiler IR). Generatorification changes that. To facilitate this phase, we created a general-purpose bytecode rewriting facility for JSC. It allows us to insert and remove any kind of bytecode instruction, including jumps. It permits us to perform sophisticated control-flow edits on the bytecode stream. We use this to make generatorification easier, and we look forward to using it to implement other crazy future language features.
To allow suspension and resumption of the execution context at op_yield, the rewriter inserts the op_switch_imm opcode just after the op_enter opcode. At the point of op_yield, the transformed function saves the integer that represents the virtual instruction pointer and then returns from the function with op_ret. Then, when resuming, we use the inserted op_switch_imm with the saved integer, jumping to the point just after the op_yield which suspended the context.
To save and restore live registers, this pass performs liveness analysis to find live registers at op_yield and then inserts op_put_to_scope and op_get_from_scope operations to save their state and restore it (respectively). These opcodes are part of our closure object model, which happens to be appropriate here because JSC’s closures are just objects that statically know what their fields are and how they will be laid out. This allows fast allocation and fast access, which we already spent a great deal of time optimizing for actual JS closures. In this figure, generatorification performs liveness analysis and finds that the variable temp is live over the op_yield point. Because of this, the rewriter emits op_put_to_scope and op_get_from_scope to save and restore temp. This does not disrupt our optimizing compiler’s ability to reason about temp‘s value, since we had already previously solved that same problem for variables saved to closures.
Summary
The generatorification rewrite used bytecode desugaring to encapsulate the whole idea of generators into a bytecode phase that emits idiomatic JSC bytecode. This allows our entire optimization infrastructure to join the generator party. Programs that use generators can now run in all of our JIT tiers. At the time this change landed, it sped up Basic’s Average score by 41%. It also improved Basic overall: even the First Iteration score got 3% faster, since our low-latency DFG optimizing JIT is designed to provide a boost even for start-up code.
The data in the above graph was taken on a Mid 2014, 2.8 GHz Core i7, 16GB RAM, 15″ MacBook Pro, running macOS Sierra version 10.12.0. Safari 10.0.2 is the first version of Safari to ship with JavaScriptCore’s complete ES6 implementation. Safari 10.0.2 does not include any of the optimizations described in this post. The above graph shows that since implementing ES6, we’ve made significant improvements to JSC’s performance running Basic. We’ve made a 1.2x improvement in the First Iteration score, a 1.4x improvement in the Worst 4 Iterations score, and a 2.8x improvement in the Average score.
Desugaring is a classic technique. Crazy compiler algorithms are easiest to think about when they are confined to their own phase, so we turned our bytecode into a full-fledged compiler IR and implemented generatorification as a compiler phase over that IR. Our new bytecode rewriter is powerful enough to support many kinds of phases. It can insert and remove any kind of bytecode instruction including jumps, allowing for complex control flow edits. While it’s only used for generators presently, this rewriting facility can be used to implement complex ECMAScript features in the future.
Fast Map and Set
Map and Set are two new APIs in ES6 that make it a more expressive language to program in. Prior to ES6, there was no official hashtable API for JavaScript. It’s always been possible to use a JavaScript object as a hashtable if only Strings and Symbols are used as keys, but this isn’t nearly as useful as a hashtable that can take any value as a key. ES6 fixes this ancient language deficiency by adding new Map and Set types that accept any JavaScript value as a key.
Both Air and Basic use Map and Set. Profiling showed that iteration and lookup were by far the most common operations, which is fairly consistent with our experience elsewhere in the language. For example, we have always found it more important to optimize property loads than property stores, because loads are so much more common. In this section we present our new Map/Set implementation, which we optimized for the iteration and lookup patterns of ARES-6.
Fast Lookup
To make lookup fast, we needed to teach our JIT compilers about the internal workings of our hashtable. The main performance benefit of doing this comes from inlining the hashtable lookup into the IR for a function. This obviates the need to call out to C++ code. It also allows us to implement the lookup more efficiently by leveraging the compiler’s smarts. To understand why, let’s analyze a hashtable lookup in more detail. JSC’s hashtable implementation is based off the linear probing algorithm. When you perform map.has(key) inside a JS program, we’re really performing a few abstract operations under the hood. Let’s break those operations down into pseudo code:
let h = hash(key);
let bucket = map.findBucket(h);
let has = !isEmptyBucket(bucket);
return has;
You can think of the findBucket(h) operation as:
let bucket = startBucket(h);
while (true) {
if (isEmptyBucket(bucket))
return emptyBucketSentinel;
// Note that the actual key comparison for ES6 Map and Set is not triple equals.
// But it's close. We can assume it's triple equals for the sake of this explanation.
if (bucket.key === key)
return bucket;
h = nextIndex(h);
}
There are many things that can be optimized here based on information we have about key. The compiler will often know the type of key, allowing it to emit a more efficient hash function, and a more efficient triple equals comparison inside the findBucket loop. The C code must handle JavaScript key values of all possible types. However, inside the compiler, if we know the type of key, we may be able to emit a triple equals comparison that is only a single machine compare instruction. The hash function over key also benefits from knowing the type of key. The C++ implementation of the hash function must handle keys of all types. This means that it’ll have to do a series of type checks on key to determine how it should be hashed. The reason for this is we hash numbers differently than strings, and differently than objects. The JIT compiler will often be able to prove the type of key, thereby allowing us to avoid multiple branches to learn key‘s type.
These changes alone already make Map and Set much faster. However, because the compiler now knows about the inner workings of a hashtable, it can further optimize code in a few neat ways. Let’s consider a common use of the Map API:
if (map.has(key))
return map.get(key);
...
To understand how our compiler optimizations come into play, let’s look at how our DFG (Data Flow Graph) IR represents this program. DFG IR is used by JSC for performing high-level JavaScript-specific optimizations, including optimizations based on speculation and self-modifying code. This hashtable program will be transformed into roughly the following DFG IR (actual DFG IR dumps have a lot more information):
DFG IR allows for precise modeling of effects of each operation as part of the clobberize analysis. We taught clobberize how to handle all of our new hashtable operations, like GetBucket, IsNonEmptyBucket, Hash, and LoadFromBucket. The DFG CSE (common subexpression elimination) phase uses this data and runs with it: it can see that the same Hash and GetBucket operations are performed twice without any operations that could change the state of the map in between them. Lots of other DFG phases use clobberize to understand the aliasing and effects of operations. This unlocks loop-invariant code motion and lots of other optimizations.
In this example, the optimized program will look like:
Our compiler was able to optimize the redundant hashtable lookups in has and get down to a single lookup. In C++, hashtable APIs go to great lengths to provide ways of avoiding redundant lookups like the one here. Since ES6 provides only very simple Map/Set APIs, it’s difficult to avoid redundant lookups. Luckily, our compiler will often get rid of them for you.
Fast Iteration
As we wrote Basic and Air, we often found ourselves iterating over Maps and Sets because writing such code is natural and convenient. Because of this, we wanted to make Map and Set iteration fast. However, it’s not immediately obvious how to do this because ES6’s Map and Set iterate over keys in insertion order. Also, if a Map or Set is modified during iteration, the iterator must reflect the modifications.
We needed to use a data structure that is fast to iterate over. An obvious choice is to use a linked list. Iterating a linked list is fast. However, testing for the existence of something inside a linked list is O(n), where n is the number of elements in the list. To accommodate the fast lookup of a hashtable, and the fast iteration of a linked list, we chose a hybrid approach of a combo linked-list hashtable. Every time something is added to a Map or Set, it goes onto the end of the linked list. Every element in the linked list is a bucket. Each entry in the hashtable’s internal lookup buffer points to a bucket inside the linked list.
This is best understood through a picture. Consider the following program:
let map = new Map;
map.set(1, "one");
map.set(2, "two");
map.set(3, "three");
A traditional linear probing hashtable would look like this:
However, in our scheme, we need to know the order in which we need to iterate the hashtable. So, our combo linked-list hashtable will look like this:
As mentioned earlier, when iterating over a Map or Set while changing it, the iterator must iterate over newly added values, and must not iterate over deleted values. Using a linked list data structure for iteration allows for a natural implementation of this requirement. Inside JSC, Map and Set iterators are just wrappers over hashtable buckets. Buckets are garbage collected, so an iterator can hang onto a bucket even after it has been removed from the hashtable. As an item is deleted from the hashtable, the bucket is removed from the linked list by updating the deleted bucket’s neighbors to now point to each other instead of the deleted bucket. Crucially, the deleted bucket will still point to its neighbors. This allows iterator objects to still point to the deleted bucket and then find their way back to non-deleted buckets. Asking such an iterator for its value will lead the iterator to traverse its neighbor pointer until it finds the next non-deleted bucket. The key insight here is that deleted buckets can always find the next non-deleted bucket by doing a succession of pointer chasing through their neighbor pointer. Note that this pointer chasing might lead the iterator to the end of the list, in which case, the iterator is closed.
For example, consider the previous program, now with the key 2 deleted:
let map = new Map;
map.set(1, "one");
map.set(2, "two");
map.set(3, "three");
map.delete(2);
Now, the hashtable will look like this:
Let’s consider what happens when there is an iterator that’s pointing to the bucket for 2. When next() is called on that iterator, it’ll first check if the bucket it’s pointing to is deleted, and if so, it will traverse the linked list until it finds the first non-deleted entry. In this example, the iterator will notice the bucket for 2 is deleted, and it will traverse to the bucket for 3. It will see that 3 is not deleted, and it will yield its value.
Summary
We found ourselves using Map/Set a lot in the ES6 code that we wrote, so we decided to optimize these data structures to further encourage their use. Our Map/Set rewrite represents the hashtable’s underlying data structures in a way that is most natural for our garbage collector and DFG compiler to reason about. At the time this rewrite was committed, it contributed to an 8% overall performance improvement on ARES-6.
Phantom Spread
Another ES6 feature we found ourselves using is the combination of the rest parameter and the spread operator. It’s an intuitive programming pattern to gather some arguments into an array using the rest parameter, and then forward them to another function call using spread. For example, here is one way we use this in the Air benchmark:
visitArg(index, func, ...args)
{
let replacement = func(this._args[index], ...args);
if (replacement)
this._args[index] = replacement;
}
A naive implementation of spread over the rest parameter will cause this code to run slower than needed because a spread operator requires performing the iterator protocol on its argument. Because the function visitArg is creating the args array, the DFG compiler knows exactly what data will be stored into it. Specifically, it’ll be filled with all but the first two arguments to visitArg. We chose to implement an optimization for this programming pattern because we think that the spread of a rest parameter will become a common ES6 programming idiom. In JSC, we also implement an optimization for the ES5 variant of this programming idiom:
foo()
{
bar.apply(null, arguments);
}
The ideal code the DFG could emit to set up the stack frame for the call to func inside visitArg is a memcpy from the arguments on its own stack frame to that of func‘s stack frame. To be able to emit such code, the DFG compiler must prove that such an optimization is sound. To do this, the DFG must prove a few things. It must first ensure that the array iterator protocol is not observable. It proves it is not observable by ensuring that:
Array.prototype[Symbol.iterator] is its original value,
By performing such a proof, the DFG knows exactly what the protocol will do and it can model its behavior internally. Secondly, the DFG must prove that the args array hasn’t changed since being populated with the values from the stack. It does this by performing an escape analysis. The escape analysis will give a conservative answer to the question: has the args array changed since its creation on entry to the function? If the answer to the question is “no”, then the DFG does not need to allocate the args array. It can simply perform a memcpy when setting up func‘s stack frame. This is a huge speed improvement for a few reasons. The primary speed gain is from avoiding performing the high-overhead iterator protocol. The secondary improvement is avoiding a heap object allocation for the args array. When the DFG succeeds at performing this optimization, we say it has converted a Spread into a PhantomSpread. This optimization leverages the DFG’s ability to not only optimize away object allocations, but to rematerialize them if speculative execution fails and we fall back to executing the bytecode without optimizations.
The data in the above graph was taken on a Mid 2014, 2.8 GHz Core i7, 16GB RAM, 15″ MacBook Pro, running macOS Sierra version 10.12.0. PhantomSpread was a significant new additionto our DFG JIT compiler. The Phantom Spread optimization, the rewrite of Map/Set, along with other overall JSC improvements, shows that we’ve sped up Air’s Average score by nearly 2x since Safari 10.0.2. Crucially, we did not introduce such a speed up at the expense of the First Iteration and Worst 4 Iterations scores. Both of those scores have also progressed.
Performance Results
We believe that a great way to keep ourselves honest about JavaScriptCore’s performance is to compare to the best performance baselines available. Therefore, we routinely compare our performance both to past versions of JavaScriptCore and to other JavaScript engines. This section shows how JavaScriptCore compares to Firefox and Chrome’s JavaScript engines.
The graphs in this section use data taken on a Late 2016, 2.9 GHz Core i5, 8GB RAM, 13″ MacBook Pro, running macOS High Sierra Beta 1.
The figure above shows the overall ARES-6 scores in three different browsers: Safari 11 (13604.1.21.0.1), Firefox 53.0.3, and Chrome 58.0.3029.110. Our data shows that we’re nearly to 1.8x faster than Chrome, and close to 5x faster than Firefox.
The graph above shows detailed results for all four benchmarks and their three scores. It shows that JavaScriptCore is the fastest engine at running ARES-6 not only in aggregate score, but also in all three scores for each individual subtest.
Conclusion
ES6 is a major improvement to the JavaScript language, and we had fun giving it a test drive when creating ARES-6. Writing Air and Basic, and importing Babylon and ML, gave us a better grasp of how ES6 features are likely to be used. Adding new benchmarks to our repertoire always teaches us new lessons. Long term, this only works to our benefit if we keep adding new benchmarks and don’t over optimize for the same set of stale benchmarks. Going forward, we plan to add more subtests to ARES-6. We think adding more tests will keep us honest in not over-tuning for specific ES6 code patterns. If you have exciting ES6 (or ES7 or beyond) code that you think is worth including in ARES-6, we’d love to hear about it. You can get in touch either by filing a bug or contacting Filip, Saam, or Yusuke, on Twitter.
The success of the web as a platform relies on user trust. Many users feel that trust is broken when they are being tracked and privacy-sensitive data about their web activity is acquired for purposes that they never agreed to.
WebKit has long included features to reduce tracking. From the very beginning, we’ve defaulted to blocking third-party cookies. Now, we’re building on that. Intelligent Tracking Prevention is a new WebKit feature that reduces cross-site tracking by further limiting cookies and other website data.
What Is Cross-Site Tracking and Third-Party Cookies?
Websites can fetch resources such as images and scripts from domains other than their own. This is referred to as cross-origin or cross-site loading, and is a powerful feature of the web. However, such loading also enables cross-site tracking of users.
Imagine a user who first browses example-products.com for a new gadget and later browses example-recipies.com for dinner ideas. If both these sites load resources from example-tracker.com and example-tracker.com has a cookie stored in the user’s browser, the owner of example-tracker.com has the ability to know that the user visited both the product website and the recipe website, what they did on those sites, what kind of web browser was used, et cetera. This is what’s called cross-site tracking and the cookie used by example-tracker.com is called a third-party cookie. In our testing we found popular websites with over 70 such trackers, all silently collecting data on users.
How Does Intelligent Tracking Prevention Work?
Intelligent Tracking Prevention collects statistics on resource loads as well as user interactions such as taps, clicks, and text entries. The statistics are put into buckets per top privately-controlled domain or TLD+1.
Machine Learning Classifier
A machine learning model is used to classify which top privately-controlled domains have the ability to track the user cross-site, based on the collected statistics. Out of the various statistics collected, three vectors turned out to have strong signal for classification based on current tracking practices: subresource under number of unique domains, sub frame under number of unique domains, and number of unique domains redirected to. All data collection and classification happens on-device.
Actions Taken After Classification
Let’s say Intelligent Tracking Prevention classifies example.com as having the ability to track the user cross-site. What happens from that point?
If the user has not interacted with example.com in the last 30 days, example.com website data and cookies are immediately purged and continue to be purged if new data is added.
However, if the user interacts with example.com as the top domain, often referred to as a first-party domain, Intelligent Tracking Prevention considers it a signal that the user is interested in the website and temporarily adjusts its behavior as depicted in this timeline:
If the user interacted with example.com the last 24 hours, its cookies will be available when example.com is a third-party. This allows for “Sign in with my X account on Y” login scenarios.
This means users only have long-term persistent cookies and website data from the sites they actually interact with and tracking data is removed proactively as they browse the web.
Partitioned Cookies
If the user interacted with example.com the last 30 days but not the last 24 hours, example.com gets to keep its cookies but they will be partitioned. Partitioned means third-parties get unique, isolated storage per top privately-controlled domain or TLD+1, e.g. account.example.com and www.example.com share the partition example.com.
This makes sure users stay logged in even if they only visit a site occasionally while restricting the use of cookies for cross-site tracking. Note that WebKit already partitions caches and HTML5 storage for all third-party domains.
What Does This Mean For Web Developers?
With Intelligent Tracking Prevention, WebKit strikes a balance between user privacy and websites’ need for on-device storage. That said, we are aware that this feature may create challenges for legitimate website storage, i.e. storage not intended for cross-site tracking. Please let us know of such cases and we will try to help (contact info at the end of this blog post).
To get you started, here are some some guidelines.
Storage Requires User Interaction
Check to make sure that you aren’t relying on cookies and other storage to persist if the user does not interact directly with your website on a regular basis. Requiring user interaction covers most legitimate uses of client-side storage. It also provides better transparency and gives users more control over who gets to store data on their devices.
Web Analytics
Make sure to configure your web analytics to not rely on third-party cookies from domains that don’t get user interaction. A popular way to do cross-site analytics for a family of sites is to use link decoration, i.e. pad links with information that needs to be carried across origins and navigations.
Ad Attribution
We recommend server-side storage for attribution of ad impressions on your website. Link decoration can be used to pass on attribution information in navigations.
Managing Single Sign-On
If you run a single sign-on system with a centralized session, the user needs to interact with the domain that controls the session. Otherwise you run the risk of Intelligent Tracking Prevention treating your session controller domain as a tracker.
Imagine a scenario as depicted above; a central session at account.com used for the three sites SiteA.com, SiteB.com, and SiteC.com. Session information can be propagated from account.com to the dependents during account.com’s 24-hour exemption from cookie partitioning. From that point on the sites must maintain sessions without account.com cookies, or they must re-authenticate daily with a brief stop at account.com to acquire new user interaction. You can grant the sites the ability to propagate session information between themselves through navigations and new cookies set in HTTP responses. Single sign-out needs to invalidate the account.com session on the server.
Feedback and Bug Reports
Please report bugs through bugs.webkit.org and send feedback to our evangelist Jon Davis if you are a web developer or a web user and Intelligent Tracking Prevention isn’t working as intended for your website. If you have technical questions on how the feature works you can find me on Twitter @johnwilander.
A new Draft Area Plan (June 2017) is available. It includes taking down the Georgia and Dunsmuir viaducts, and covers transformation of around 58 hectares (143 acres), or roughly 10% of Vancouver’s downtown peninsula (excluding Stanley Park).
You can attend an open house & block party event on Saturday June 10 (11 – 7) to check out these plans and talk to city staff about what you love or loathe.
You may want to dive in to the Draft Area Plan (HERE152-page PDF). You can see what the engineers, designers and around 8,200 people they consulted came up with.
Here’s one small example: Main St. (Prior-Union area) in an artist’s rendering, pre-and-post-viaducts.
Confirming prior rumors, Tim Cook announced today that Amazon Prime Video would be coming to the Apple TV later this year. The news was the first of six main announcements made by Apple at today's WWDC keynote. Cook included the detail that not only would Prime Video be available on Apple TV, but it will also integrate with Apple's TV app – welcome news for myself and all who use the TV app regularly.
Prime Video arriving on Apple TV ends the last prominent holdout from a major streaming service on Apple's platform. And its integration with the TV app leaves Netflix as the single largest holdout that does not yet support the TV app.
The introductory news about Amazon was the only Apple TV-specific announcement made today, which was a disappointment as it was widely expected that Apple would introduce the next major version of tvOS alongside revisions to its other software platforms. Cook did note that we should expect to hear more about developments with tvOS later this year, indicating that a major update may be forthcoming, but simply wasn't ready in time to show at WWDC.
As its name may suggest, Apple’s latest Mac operating system, macOS High Sierra, was billed today as a performance update for macOS. Packed deep with improvements to macOS apps and system-level functionality, High Sierra brings welcome changes to the Mac.
Additionally, Apple introduced important new technologies in macOS, including support for virtual reality, its new file system APFS, and Metal 2.
Photos
Today’s announcement brought big updates to Photos, including the ever-requested face recognition syncing across all devices. For better navigation and organization, Photos sports an expanded sidebar and photo filtering by criteria, as well as new curated Memories that include weddings, pets, and more.
Editing in Photos is now far more robust, with new editing options and a suite of Live Photo enhancement tools. These changes inch Photos ever so slightly nearer to more professional tools, but don’t expect to switch from Photoshop anytime soon.
Safari
To combat some of the internet’s more frustrating tendencies, Safari received support for “intelligent tracking prevention,” preventing online advertisers from tracking your viewing history and serving you ads. And, to further alleviate your stress while browsing, Safari can now detect videos that autoplay and will stop them before they start.
Safari also brings more customization to the browsing experience, including settings centered around content blockers, Reader, and more. It’s great to see Safari receive meaningful updates that help it compete with Chrome, all while remaining lightweight and stable.
iCloud
Users with multiple Apple devices know the struggle of managing messages across iOS and macOS. But struggle no longer: messages are now synced in iCloud, meaning messages will be saved, deleted, and updated across all devices. When you buy a new Mac and sign in with iCloud, all of your messages will appear there.
Sharing saw big changes, too, with linked files in iCloud and iCloud storage plans for the entire family. The latter is especially important, as it allows you to share either 200GB or 2TB between family members for all iCloud data.
New Technologies
Last summer Apple introduced APFS, the company’s latest file system to be rolled out on both macOS and iOS. APFS arrived on iOS devices earlier this year in iOS 10.3, and now Apple is bringing APFS to the Mac in macOS High Sierra. The new file system boasts “advanced architecture that brings a new level of security and responsiveness.”
For video, gaming, and more, Apple had a lot to announce. Although it pleased the crowd with HEVC, a new compression system, it wowed with news of virtual reality for the Mac. Through a lengthy VR demo and an in-depth explainer, Apple touted macOS High Sierra as a huge release for developers interested in the VR space. By announcing partnerships with industry players Steam and HTC and detailing Metal 2, Apple proved that it is serious about bringing VR to the Mac.
Miscellaneous
As always, Apple leaves a lot of changes to be discovered or talked about later. Here are some of the notable phrases from Apple’s “refinements” slide that was shown during the keynote:
Compressed Mail storage
Mail search Top Hits
New Siri voice
Pinned notes
Photos import history
Notes with tables
Many refinements for macOS High Sierra can also be found in iOS 11, showcasing Apple’s commitment to providing a unified experience across platforms. Through adding on and refining macOS Sierra, Apple followed their own example set during the days of OS X Snow Leopard; if macOS High Sierra provides the same level of stability and improvement as Snow Leopard did to Leopard, Mac users will be thrilled come this fall.
At its annual developer conference, Apple refreshed its lineup of iMac desktop computers.
Apple has refreshed the entire lineup with new displays that are at 500 nits 43 percent brighter than the screens found on the current iMacs. The new displays also support 10-bit dithering, allowing them to display more than 1-billion colours.
Each and every iMac will now also ship with Intel’s latest seventh generation ‘Kaby Lake’ processors. Additionally, depending on the size of the model, the new iMacs will support up to 32GB and 64GB RAM, twice as much as the previous generation.
The company’s fusion drives are now standard on all 27-inch iMacs. The company has added two USB-C Thunderbolt 3 ports to all models.
Last but not least, each model will get a GPU upgrade. All four 4K iMacs will now ship with discrete AMD GPUs. The most powerful iMac, meanwhile, will ship with an 8GB GPU.
Apple has confirmed Canadian pricing information for the new Mac devices. They will retail for $1,729 CAD and will be available in Apple Stores across Canada starting on Wednesday, June 7th.
Today at WWDC 2017 in San Jose, Apple announced its newest version of the macOS High Sierra.
Safari
Apple says Safari is the world’s fastest desktop browser with High Sierra; it’s now 80 percent faster than Chrome, using the newest form of Javascript. Additionally, Safari now has Autoplay Blocking with Safari, to avoid annoying surprise video ads in browsers. Furthermore, it uses Intelligent Tracking Prevention that uses machine learning to identify trackers and protect users’ privacy.
Mail
Now, High Sierra is also using split view for composing mail and spotlight to find exactly what you’re looking for, while putting the most important mail at the top. Additionally, the mail app is more efficient using 35 percent less disk space when storing mail.
Photos
The Photos app adds persistent sidebar and new view that has all of an user’s imports in chronological order to help find everything being looked for. On the top right, Apple has added filters to any screen within the Photos app so users can sort through their favourite images.
Apple also upgraded faces with new technology that helps with identifying faces on macOS devices, and when users add names to these faces the technology helps identify faces across all Apple devices.
Within the Photos app, Apple has added many tools for editing such curves so users can ‘fine tune’ their photos within the app, as well as selective colour so users can modify colours. Furthermore, Apple included a functionality that allows all of the edits made on Photoshop or another photo editing tool, to automatically save itself on the High Sierra Photos app.
Apple is bringing the apple file system to macOS as the new default. This makes duplicating files a lot quicker on your High Sierra Mac and much more.
HEVC
MacOS added High Efficiency Video Coding (HEVC, also known as H.265) can compress video up to 40 percent more than H.264, that is currently used for video compression. HEVC will stream video better, take up less space on your Mac.
Metal 2
Graphics of the new High Sierra, uses new technology called Metal 2, that’s supposed to be very fast. Metal 2 is 10x faster than the first Metal and is 100x improvement over openGL technology for graphics. Now, the mac window server uses Metal 2 making opening new windows and challenging system animations buttery smooth.
Metal is now available external graphics. Apple is starting with a developer kit, for Metal 2 so that developers can use Metal 2 for apps they’re working on. Support for all of Apple’s customers will be coming in the months to come.
Virtual Reality
MacOS High Sierra supports VR , with the HTC Vive Vr headset, users will be able to use apps like Final Cut Pro X, Epic Unreal 4 Editor, and SteamVR. Furthermore, developers will have what they need to create VR content.
High Sierra is now downloadable today for developers and a public Beta will be available later this June. Furthermore, High Sierra is set to be available as a free update this fall, for everyone who has Sierra on their devices.
The most recent version of macOS Sierra 10.12.15 improved “stability and compatibility and security of your Mac,” according to Apple.
A little reminder of what Apple did a year ago at WWDC 2016. The company rebranded OSX 10.12 as macOS Sierra, that featured Apple’s automated assistant Siri. Last year’s update added the functionality to Sierra allowing for macOS devices to be auto unlocked by the Apple Watch . Furthermore, Apple included an Universal Clipboard which allowed for copying and pasting from your Macbook to an iPhone, picture-in-picture support for its macOS, and Apple Pay. Lastly, Apple allowed for all of your Macbook files to be accessible from other Apple devices.
While we’ve grown used to the idea of Google’s StreetView cars zooming around town snapping photos for mapping purposes, some of those vehicles have been equipped with a pollution monitoring system to help researchers get a better picture of what is in the air we breathe every day.
The cars have been driving for up to eight hours a day around Oakland and sampling every street in a certain area of the city to collect urban air pollution data, according to a new study published by researchers at the University of Texas at Austin.
They’ve made three million unique measurements while driving more than 14,000 miles, creating “one of the largest, most spatially precise datasets of mobile air pollution measurements ever assembled.” It’s all part of a partnership between Google and the Environmental Defense Fund.
“Maybe the most striking thing is how much air pollution can vary even within a city block,” Joshua Apte, an assistant engineering professor at the University of Texas at Austin and lead author of the study, told Fast Company. “One end of the block could be five, eight times more polluted than the other end of the block.”
For example: Researchers found that streets with city bus routes were more polluted than those without, and neighborhoods closer to highways that ban trucks are less polluted than those near interstates that have truck traffic.
You could use such detailed data to make decisions on whether or not to buy a house, or push for change in your neighborhood. Cities could also use it to improve certain areas, or show the positive effects of efforts to cut down on pollution.
“Our findings validated community concerns about poor air quality near the port and major freeways,” Steven Hamburg, EDF Chief Scientist, said “But it’s also shocking to see how close homes and playgrounds have been built—and are continuing to be placed—near major pollution sources. This data can inform decisions about zoning and planning and result in concrete health benefits for communities.”
The hope is that this system could eventually roll out in other cities and other kinds of vehicles: Aclima is currently working on a smaller prototype of its system that could be deployed even in compact vehicles.
Apple today announced iOS 11, the latest version of its mobile operating system.
Starting with Messages, Apple has redesigned the chat app with a new app drawer that allows easy access to other apps on the user’s iPhone. The company has also added support for iCloud to the app, allowing users to synchronize messages across devices.
With iOS 11, the company is also adding peer-to-peer payments to Apple Pay. Users can send payments to their friends and family members with Messages.
Apple has also given Siri a major makeover. For the first time since the company introduced the personal assistant, Siri has a new voice. Once iOS 11 lands later this fall, Siri will be able to translate text and speech into different languages.
iOS is also getting a variety of photo and video improvements. Most notably, Apple is moving to HEVC for video encoding. According to Apple’s Craig Federighi, the codex is twice as efficient when it comes to data compression. Using new artificial intelligence algorithms, the company’s Photos app features improved . The app will now be able to tell the orientation of the user’s device and automatically adjust the
The company also plans to add a new “Do Not Disturb While Driving” mode. By default, when the mode is activated the iPhone will display a simple black screen. Non-vital notifications will not be pushed through the iPhone in this mode.
Perhaps most notably, iOS 11 features a redesign Action Centre that takes the previous two-page design and puts all the different toggles onto one page.
Siri isn’t the only app that’s getting a redesign. The App Store is getting its first redesign in its nine-year history. Like Apple Music, the new app store will be designed around a ‘Today’ tab that highlights new releases. Apple also plans to add a new Games tab.
The interface is built around cards that include curated written content like feature pieces and how-tos. Apple also plans to highlight daily app and games of the week.
On the technology front, the company plans to open up its AI APIs to developers. Devs will be able to add features like face detection to their apps and take advantage of the iPhone’s computing power to improve their apps.
Besides AI, Apple is also investing into augmented reality with a new SDK built around AR called ARKit. The tool allows developers to use the iPhone’s cameras and processing power to develop sophisticated AR apps.
Even existing apps like Pokémon GO will benefit from the company’s new APIs with the ability to add sophisticated object tracking and on-screen visual effects.
iOS 11 will also include a number of iPad-centric improvements. Starting with the new operating system, the iPad will feature a macOS-like dock that allows users to store their favourite apps along the bottom of the iPad’s display. In contrast to the current dock, it allows users to add more than just a couple of apps for quick access.
Apple also plans to add enhanced drag and drop support to its tablet, allowing users to drag almost any part of the interface. The company will also release a Files app that allows users to see all the files on their iPad’s internal storage. The app will be able to access third-party storage solutions like Box and Dropbox.
Taking a page from Microsoft, iOS 11 will feature a markup feature that will allow users to use Apple Pencil to write and draw directly within select apps, including Notes and Safari.
Not to be outdone, Lenox Hill Hospital in New York recently hired a veteran of Louis Vuitton and Nordstrom, Joe Leggio, to create an atmosphere that would remind V.I.P. patients of visiting a luxury boutique or hotel, not a hospital. “This is something that patients asked for, and we want to go from three-star service to five-star service,” said Mr. Leggio, the hospital’s director of patient and customer experience.
In its maternity ward, the Park Avenue Suite costs $2,400 per night, twice what a deluxe suite at the Carlyle Hotel down the street commands, but that’s not a problem for well-heeled new parents. Beyoncé and Jay Z welcomed their baby, Blue Ivy, into the world at Lenox Hill, as did Chelsea Clinton and her husband, and Simon Cowell and his girlfriend.
With a separate sitting room for family members, a kitchenette and a full wardrobe closet, the suite overlooking Park Avenue is a world away from the semiprivate experience upstairs at the hospital, where families share an old-fashioned room divided by a curtain. Slightly less exalted but still private rooms in Lenox Hill’s maternity ward range from $630 to $1,700 per night.
As the stream of celebrity couples suggests, there is plenty of demand for these upscale options, crowding out traditional maternity wards. Lenox Hill is replacing some of its shared maternity rooms with private rooms, a far more profitable offering for hospitals since patients pay for them out of pocket, not through insurance plans that can bargain down rates.
Hospital executives argue that giving the well heeled extra attention is a way of keeping the lights on and providing care for ordinary middle- and even upper-middle-class patients, as reimbursements from private insurers and the federal government shrink. “I need to succeed to pay for the children we are bringing in from all over the world and treat for free,” said Dr. Angelo Acquista, a veteran pulmonologist who leads Lenox Hill’s executive health and international outreach programs.
Then there are the red blankets that some big Stanford benefactors receive when they check in as patients. For doctors and nurses, it is a quiet sign of these donors’ special status, which is also noted in their medical records.
“You don’t get better care,” Dr. Jones said. “But maybe the dean comes by, and if it’s done well, it’s done invisibly. It’s an acknowledgment of a contribution to the organization.”
Valuing Relationships
Rex Chiu, an internist with Private Medical in Menlo Park, spent more than a decade as a doctor on Stanford’s faculty. “I loved my time at Stanford, but I was spending less and less time with patients,” he said. “Fifteen or 20 minutes a year with each patient isn’t enough.”
“We all say we should get the same care, but I got sick and tired of waiting for that to happen,” he added. “I decided to go for quality, not quantity.”
Besides more money, the calmer pace of high-end concierge medicine is also a major selling point for physicians — Dr. Matles said he never made it to an event at his children’s school until he joined MD Squared. But for Dr. Sarah Greene, it wasn’t really the money or the lifestyle that led her to Private Medical.
“I really have time to think about my patients when they’re not in front of me,” said Dr. Greene, a pediatrician who joined the company’s Los Angeles practice in October. “I may spend a morning researching and emailing specialists for one patient. Before, I had to see 10 patients in a morning, and could never spend that kind of time on one case.”
Getting in the door as a new hire isn’t easy. When it comes to credentials like college, medical school and residency, Dr. Shlain said, “at least two out of the three need to be Ivy League, or Ivy League-esque.”
In many ways, today’s elite concierge physician provides the same service as the family doctor did a half-century ago for millions of Americans, except that it is reserved for the tiny sliver of the population who can pay tens of thousands of dollars annually for it.
“I didn’t know this level of care was possible,” said Trevor Traina, a serial entrepreneur here who is a patient of Dr. Shlain’s. “I have a better relationship with my veterinarian than the doctors I went to in the past.”
What about everyone else? Mr. Traina doesn’t see much future for the conventional family doctor, except for patients who go the concierge route.
“The traditional model of having a good internist is dying,” said Mr. Traina, a scion of a prominent family here that arrived with the California Gold Rush. “Even the 25-year-olds at my company either have some form of concierge doc, or they’ll just go to an H.M.O. or a walk-in clinic. No one here has a regular doctor anymore.”
Apple’s newest macOS update, High Sierra, as well as the company’s updated iMacs are now optimized with native support for virtual reality.
MacOS High Sierra is powered by Metal 2 — an update to the Metal graphics accelerator first released in 2014.
Metal 2 comes with native support for virtual reality, which allows the newest iMacs to process high intensity VR programs.
Industrial Light and Magic’s (ILM) John Knoll’s took to the stage to showcase the iMacs’s capacity for virtual reality.
In a demo led by Epic Games’ Lauren Ridge, a scene was assembled from a Star Wars-related. Wearing an HTC Vive device, Ridge was able to compile and playback the scene in real-time.
Apple has been hinting for some time that it’s interested in pursuing some form of virtual reality, and the latest news from WWDC 2017 indicate that the Cupertino giant is ready to make a play in the VR market.
During Apple’s keynote presentation at WWDC 2017, Tim Cook announced this is “the biggest WWDC ever.” There were over 16 million registered developers in the program, up from 3 million last year and over 5,300 developers at WWDC attending WWDC 2017.
Following the announcement of Watch OS 4 and a slew of new Macs, Cook announced iOS 11 with a jab at the fragmented adoption of Google’s latest OS update, Android 7.0. Cook noted that 86 percent of iPhone users are now running on iOS 10, and “this blows away the other platforms.”
In an attempt to take on mobile payment apps like Venmo and Tilt, Apple’s announced that Apple Pay will be available for person-to-person monetary exchanges.
iOS device owners will be able to use Apple Pay to exchange money with other iOS device owners through the iMessage app.
In a demonstration, Apple senior vice president of software Craig Federighi received a message from a contact claiming that Federighi owed $20.
The Apple keyboard not only presented an Apple Pay icon, but by studying the content of the message, Apple Pay suggested that Federighi transfer $20 to the person he owed.
The updated Apple Pay will be cross-platform across iPhone, iPad, and Apple Watch.
The Apple Pay update was unveiled at WWDC 2017, and will launch with iOS 11 later this year.
Apple’s wants to put a stop to distracted driving.
During WWDC 2017, the Cupertino giant announced that it’s bringing a new feature to iOS 11 that will prevent iPhone users from sending and receiving updates while driving: a ‘do not disturb while driving’ feature.
Do not disturb while driving activates if an iPhone recognizes that it’s connected to a car via Bluetooth.
If drivers don’t have Bluetooth-enabled on their vehicles, the iPhone will use doppler shift Wi-Fi to track the phone’s presence.
Once an iPhone has recognized that users are driving, the phone will notify the users that they have the option of enabling the do not disturb feature.
If users receive messages while the feature is activated, do not disturb will send out an automatically generated message indicated that the recipient is unable to respond and will respond once they are no longer driving.
Urgent messages can still be sent and received.
Do not disturb while driving will be available with iOS 11, which will be released later this year.
Consumerist.
