Skip to main content

Highlights from the TC52 meeting on September 21, 2015

Last month we had the 9th TC52 meeting where we discussed a number of additional language features for Dart. Below is a list of the main features discussed - most noticeably the lifting of restrictions on mixins.


DEP update
There is a rich supply of Dart Enhancement Proposals under consideration, and we spent some time discussing the underlying ideas and motivations for several DEPs.

Language extensions and modifications under consideration
Several language extensions and modifications are currently being considered in more concrete terms.

  • Generic methods
    This is the most complicated DEP, in particular with respect to reification of the type arguments and other typing issues. Since the previous meeting work has been conducted on prototyping features relating to this DEP, and the impact on libraries has been explored. Among the big concerns are compatibility and implementation efforts. This might not materialize before 2016.
  • Constant context, constant functions
    One DEP is concerned with constant contexts. They would enable many occurrences of the keyword const to be omitted, based on being part of a larger const expression. An upcoming DEP proposes constant functions, i.e., functions that map constants to constants. Concern was expressed that constants are already rather complex. In general, we wish to keep things more stable than they have been recently.
  • Import configuration
    There are many proposals for how to express configurable imports, in particular with respect to the level of static checking, and the support for library interfaces. These DEPs will not be finalized in this round.
  • Metaclasses
    This DEP proposes that Type objects should have more behavior. Not much has happened in this area since the previous meeting.
  • Relaxing restrictions on Mixins
    Three restrictions on mixin have been in place since their introduction in Dart. A DEP proposal for lifting two of them is available. An implementation of both features is largely ready. In particular, it has been implemented in the virtual machine dart, but work is still ongoing for dart2js.
    The situation is as follows: There was an original proposal encompassing a rather complete feature set. This proposal was restricted, in order to make it more implementable, such that mixins must inherit from Object; mixins cannot contain super calls; and mixins cannot define constructors. We are lifting the first two of these restrictions, and keeping the third one in place at this point.
  • Null-aware operators
    This feature has been adopted into the specification and implemented. It has been very well received.
  • Generalized tear-offs
    This feature has been adopted and mostly implemented. There are still a number of known bugs.
  • Package specification
    The language specification will state that this is an implementation dependent area. The use of a file named .packages to support the semantics of ‘package:’ imports has been implemented, and the detailed approach requires a little more flexibility than the existing specification allows. In general, we do not want to constantly adjust the specification to fit the needs of tools, which means that we will add flexibility rather than detail in these areas.
  • Function
    The type Function has been used in practice as a catch-all type for functions, providing the information that a given object is intended to be used as a function, but omitting information about the number, kinds, and names of arguments as well as their types, and about the return type. Following the current language specification, Function does not have a call method, so a conforming tool (compiler, analyzer, etc.) must warn at every invocation. However, the tools have not been doing that so far. The specification will be adjusted to make Function a special case, such that the omission of these warning will be the correct behavior. We will probably treat Function as a ‘magic type’ that supports call with all shapes of argument list, and returns a value of type dynamic.
  • Function subtyping
    The proposal makes function subtyping covariant in the return type, which is required in order to support message safety and in order to make refactoring safer. We discussed whether or not this topic should be considered to be part of the DEP on generic methods.
  • Library name conflict warnings
    The issue is that many programmers leave out the library directive, which means that they give their libraries the empty name; with two such libraries there is a conflict because they have the same name. The slides suggest that the solution to the problem of conflicting library names is to give them a name based on the URI. However, the decision was actually to treat libraries whose name is the empty string specially, and not give a warning in that case.
  • ‘noSuchMethod’ type checking
    We also discussed the liberalized rule for type checking classes other than Object with an implementation of noSuchMethod(). If a class implements an interface but lacks one of the methods of the interface, or if a concrete class has an abstract method, this usually causes a warning. An exception to this rule is when the class declares a noSuchMethod(). We propose to liberalize this so that an inherited noSuchMethod() suffices (except the one from Object of course).
  • Assert messages
    A new DEP is upcoming, on adding a string message to assert.

The committee unanimously approved the proposal for a 4th edition of the Ecma-408 standard - including the lifting of mixin restrictions. We're now awaiting approval from the Ecma General Assembly in December, 2015. The next TC52 meeting will be held on January 13, 2016.

Popular posts from this blog

AngularDart 4

AngularDart v4 is now available. We've been busy since the release angular2 v3.1.0 in May. Not only did we "drop the 2", but we also improved the compiler and tightened up the framework to give you smaller code, we updated the package structure to improve usability, and we added several new features. Check out the updated documentation to get started.
Just angular Upgrading to v4 will require more than updating your version constraint. The package has changed names (back) to angular – dropping the 2. You'll need to update your pubspec.yaml and the corresponding imports in your code. In most instances, find-and-replace should do the trick. Going forward, the package will be called package:angular. We'll just update the version number.
Smaller code The updated compiler in 4.0 allows type-based optimizations that not only improve runtime performance but generate better code because we are able to strongly type templates. A big result of the update is that many ap…

The new AdWords UI uses Dart — we asked why

Google just announced a re-designed AdWords experience. In case you’re not familiar with AdWords: businesses use it to advertise on google.com and partner websites. Advertising makes up majority of Google’s revenue, so when Google decides to completely redo the customer-facing front end to it, it’s a big deal. The Dart team is proud to say that this new front end is built with Dart and Angular 2. Whenever you asked us whether Google is ‘even using Dart for anything,’ this is what we had in mind but couldn’t say aloud. Until now. We asked Joshy Joseph, the primary technical lead on the project, some questions. Joshy is focusing on things like infrastructure, application latency and development velocity, so he’s the right person to ask about Dart.Q: What exactly did we launch on Monday?It’s a complete redesign of the AdWords customer experience that is rolling out slowly as a test to a small initial set of advertisers. The most noticeable thing is probably the Material Design look and f…

Const, Static, Final, Oh my!

Posted by Seth Ladd

(This is an "oldie but a goodie" misc@dartlang.org post originally written by Bob Nystrom. It is being posted here as the explanations still ring true.)

Bob writes:


"static", "final", and "const" mean entirely distinct things in Dart:

"static" means a member is available on the class itself instead of on instances of the class. That's all it means, and it isn't used for anything else. static modifies *members*.

"final" means single-assignment: a final variable or field *must* have an initializer. Once assigned a value, a final variable's value cannot be changed. final modifies *variables*.

"const" has a meaning that's a bit more complex and subtle in Dart. const modifies *values*. You can use it when creating collections, like const [1, 2, 3], and when constructing objects (instead of new) like const Point(2, 3). Here, const means that the object's entire deep state can be determ…