Portugal December 2015

Has the Zoe finally reached its full potential?

  

Outlander PHEV Conquers #1

EV Sales are smoking hot in Portugal, with sales reaching 250 units in December, up five fold regarding the same month last year and selling more in one month than in the whole year of 2013...

With YTD sales ending at 1.305 units, up 260% regarding 2014, the EV Share ended at 0,61%, a significant departure from the 0,25% of last year, a rise not so spectacular as total sales, because the general market also grew in double digits.

Looking at the models ranking, the Mitsubishi Outlander PHEV was the surprising winner of the Best Seller title, growing from #4 and 39 units in 2014, to the current #1, with 229 units.

The remaining podium seats were for the Nissan Leaf (Second) and BMW i3 (Third), both of them benefiting from sales pushes by their respective brands in December, an aspect that local importers finally seem to have dedicated themselves to do.

The most flagrant example of this is the Renault Zoe, which has sold a record 63 units last month,a new all-time monthly record in this market, collecting only its third Monthly Best Seller trophy (The previous were in Dec. '14 and Oct. '15), an odd fact for a model that has been on sale for over two years, especially considering that Renault has the largest dealership network in Portugal and is the best selling automotive brand.

An interesting case is the Mercedes C350e, Rookie of the Year, ending the year in #5, meaning that fleet/company managers are finally adhering to the substantial company incentives.

In the manufacturers ranking, Nissan (19%) recovered just in time to win its third manufacturers title (2010, 2011 & 2015), reaching Renault (Best Seller in 2012, 2013 & 2014) as the brand with most trophies here.

Renault also took the profit from a great December to reach Second Place (18% share and 238 units), dropping Mitsubishi (18% and 235 units) to Third Place.

After 2015 having been the Year One AT (After Troika), it looks that the EV market has finally to grow significantly, so i would say some 2.500 units will be sold during 2016, with the EV Share staying firmly north of the 1% barrier. Regarding models, the Zoe finally looks poised to run for the leadership, looking to outsell the Outlander PHEV, BMW i3 and Nissan Leaf, while the Mercedes C350e and VW Passat GTE might play the dark horse card that Mitsubishi did so well in 2015.

Pl	Portugal	Dec.	2015	%	Pl '14
1	Mitsubishi Outlander PHEV	13	229	18	4
2	Nissan Leaf	34	209	16	2
3 4	BMW i3 * Renault Zoe	40 63	162 153	12 12	1 5
5 6 6 8 9 10 11 12 12 14 15 16 16	Mercedes C350e Renault Twizy Peugeot iOn Toyota Prius Plug-In Volvo V60 Plug-In Nissan e-NV200 / Evalia Volkswagen Golf GTE Renault Kangoo ZE Citroen C-Zero Volkswagen e-Up! Mercedes B-Class ED Tesla Model S e) Volkswagen e-Golf	32 3 9 6 9 12 2 12 4 1 4	80 58 58 47 38 36 33 27 27 22 17 15 15	6 4 4 4 3 3 2 2 2 2 1 1 1	N/A 3 20 12 14 8 N/A 8 20 11 N/A N/A 15
18 18 20 20 22 23 24 25 25 25 28 28 30	Audi A3 e-Tron Porsche Cayenne Plug-In Mercedes S500e BMW i8 Smart Fortwo ED Mistusbishi I-Miev Opel Ampera Porsche Panamera Plug-In BMW X5 40e PHEV Kia Soul EV Peugeot Partner EV Volvo XC90 T8 PHEV Citroen Berlingo EV	1 2 2 1	13 13 11 11 7 6 4 3 3 3 2 2 1	1 1 1 1 1 0 0 0 0 0 0 0 0	N/A 13 N/A 7 6 15 18 8 N/A N/A N/A N/A 20
	TOTAL	250	1.305	100

Source: ACAP

* - 39 Bev + 1 Rex

Plug-Ins Versus Regular Hybrids

Pl	Model	2015
1	Toyota Auris Hybrid	736
2	Toyota Yaris Hybrid	547
3	Mitsubishi Outlander PHEV	229
4	Nissan Leaf	209
5	BMW i3	162

  
If we combine regular hybrid sales with plug-ins, only the Auris Hybrid and Yaris Hybrid, both from Toyota, are outselling plug-ins. If the Auris seems out of reach for the moment, the Yaris Hybrid might see its second place in danger, especially if Renault starts to market the Zoe in a serious fashion.

Read More

V8 Release 4.9

Roughly every six weeks, we create a new branch of V8 as part of our release process. Each version is branched from V8’s git master immediately before Chrome branches for a Chrome Beta milestone. Today we’re pleased to announce our newest branch, V8 version 4.9, which will be in beta until it is released in coordination with Chrome 49 Stable. V8 4.9 is filled will all sorts of developer-facing goodies, so we’d like to give you a preview of some of the highlights in anticipation of the release in several weeks.

91% ECMAScript 2015 (ES6) support

In V8 release 4.9 we shipped more JavaScript ES2015 features than in any other previous release, bringing us to 91% completion as measured by the Kangax compatibility table (as of January 26). V8 now supports destructuring, default parameters, Proxy objects, and the Reflect API. Release 4.9 also makes block level constructs such as class and let available outside of strict mode and adds support for the sticky flag on regular expressions and customizable Object.prototype.toString output.

Destructuring

Variable declarations, parameters, and assignments now support destructuring of objects and arrays via patterns. For example:

let o = {a: [1, 2, 3], b: {p: 4}, c: {q: 5}};
let {a: [x, y], b: {p}, c, d} = o;            // x=1, y=2, p=4, c={q: 5}
[x, y] = [y, x];                              // x=2, y=1
function f({a, b}) { return [a, b] }
f({a: 4})                                     // [4, undefined]

Array patterns can contain rest patterns that are assigned the remainder of the array:

let [x, y, ...r] = [1, 2, 3, 4];              // x=1, y=2, r=[3,4]

Furthermore, pattern elements can be given default values, which are used in case the respective property has no match:

let {a: x, b: y = x} = {a: 4};                // x=4, y=4
let [x, y = 0, z = 0] = [1, 2];               // x=1, y=2, z=0

Destructuring can be used to make accessing data from objects and arrays more compact.

Proxies & Reflect

After years of development, V8 now ships with a complete implementation of proxies, up-to-date with the ES2015 spec. Proxies are a powerful mechanism for virtualizing objects and functions through a set of developer-provided hooks to customize property accesses. In addition to object virtualization, proxies can be used to implement interception, add validation for property setting, simplify debugging and profiling, and unlock advanced abstractions like membranes.

To proxy an object, you must create a handler placeholder object that defines various traps and apply it to the target object which the proxy virtualizes:

let target = {};
let handler = {
  get(target, name="world") {
    return `Hello, ${name}!`;
  }
};

let foo = new Proxy(target, handler);
foo.bar  // "Hello, bar!"

The Proxy object is accompanied by the Reflect module, which defines suitable defaults for all proxy traps:

let debugMe = new Proxy({}, {
  get(target, name, receiver) {
    console.log(`Debug: get called for field: ${name}`);
    return Reflect.get(target, name, receiver);
  },
  set(target, name, value, receiver) {
    console.log(`Debug: set called for field: ${name}, and value: ${value}`);
    return Reflect.set(target, name, value, receiver);
  }
});

debugMe.name = "John Doe";
// Debug: set called for field: name, and value: John Doe
let title = `Mr. ${debugMe.name}`; // "Mr. John Doe"
// Debug: get called for field: name

For more information on the usage of Proxies and the Reflect API, see the examples section of the MDN Proxy page and look out for our upcoming Proxies article on the Web Fundamentals blog.

Default Parameters

In ES5 and below, optional parameters in function definitions required boilerplate code to check whether parameters were undefined:

function sublist(list, start, end) {
  if (typeof start === "undefined") start = 0;
  if (typeof end === "undefined") end = list.length;
  ...
}

ES2015 now allows function parameters to have default values, providing for clearer and more succinct function definitions:

function sublist(list, start = 0, end = list.length) { ... }
sublist([1, 2, 3], 1)  // sublist([1, 2, 3], 1, 3)

Default parameters and destructuring can be combined, of course:

function vector([x, y, z] = []) { ... }

Classes & lexical declarations in sloppy mode

V8 has supported lexical declarations (let, const, block-local function) and classes since versions 4.1 and 4.2 respectively, but so far strict mode has been required in order to use them. As of V8 release 4.9, all of these features are now enabled outside of strict mode as well, per the ES2015 spec. This makes prototyping in the DevTools Console much easier, although we encourage developers in general to upgrade to strict mode for new code.

Regular expressions

V8 now supports the new sticky flag on regular expressions. The sticky flag toggles whether searches in strings start from the beginning of the string (normal) or from the lastIndex property (sticky). This behavior is useful for efficiently parsing arbitrarily long input strings with many different regular expressions. To enable sticky searching, add the y flag to a regex: (e.g. var regex = /foo/y; ).

Customizable Object.prototype.toString output

Using Symbol.toStringTag, user-defined types can now return customized output when passed to Object.prototype.toString (either directly or as a result of string coercion):

class Custom {
  get [Symbol.toStringTag]() {
    return "Custom"
  }
}
Object.prototype.toString.call(new Custom)  // "[object Custom]"
String(new Custom)                          // "[object Custom]"

Improved Math.random()

V8 4.9 includes an improvement in the implementation of Math.random(). As announced last month, we switched V8’s PRNG algorithm to xorshift128+ in order to provide higher-quality pseudo-randomness.

V8 API

Please check out our summary of API changes. This document gets regularly updated a few weeks after each major release.

Developers with an active V8 checkout can use git checkout -b 4.9 -t branch-heads/4.9 to experiment with the new features in V8 4.9. Alternatively you can subscribe to Chrome's Beta channel and try the new features out yourself soon.

Posted by the V8 team

Read More