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

Dart in 2016: The fastest growing programming language at Google, 2nd fastest growing in TIOBE Index

Dart was the fastest growing programming language at Google in 2016 with millions of lines of code written. It also made it to TIOBE Index Top 20 this month (see TIOBE's methodology).

It takes time to build something as ambitious as Dart and, in some ways, Dart is still in its infancy. But we're glad the hard work is starting to pay off.

Many thanks to our amazing community!

We're going to celebrate by ... releasing 1.22 next week (as per our usual 6 week release schedule).

A stronger Dart for everyone

We are constantly asking ourselves:
How do we make developers even more productive when writing Dart apps? We believe that a critical part of the answer to this question is to make strongmode – a sound static type system for Dart – the standard for all Dart developers.

Teams that use Dart to build apps like Soundtrap, AdWords, AdSense, and Greentea say they really enjoy using strong mode features, such as early error detection. In fact, teams that have switched completely to strong mode cite not only early error detection but also better code readability and maintainability as major benefits. We hear this both from small teams and Рeven more so Рfrom large teams with hundreds of developers writing and maintaining millions of lines of Dart code. As Björn Sperber from Soundtrap says,
Strong mode and the smooth integration with IntelliJ is a joy to use and a huge improvement. If you’ve tried out Flutter, you’ve already used strong mode checks from the Dart analyzer.

Given the benefits …

AngularDart 2.1 and new Components

AngularDart got its own dedicated team 5 months ago. Last month, we launched 2.0 final on the Dart Developer Summit. Today, we’re releasing the first minor release after that: 2.1.

Since the focus of AngularDart is Productivity, Performance, Stability, there are no major breaking changes (see the changelog) — but a lot of behind-the-scenes improvements. Your apps will get slightly smaller and faster (even relative to 2.0 which already made huge strides in size and performance since the compiled-from-TypeScript days).

Many features that AngularJS had to implement for JavaScript and TypeScript are not needed in Dart (because Dart already has those features out-of-the-box). So we’re removing them from AngularDart. Renderer is deprecated in favor of plain-old dart:html. NgPlural is going away — Dart programs can use the package:intl library.

New components

On the Dart Developer Summit, we launched AngularDart Components — the material design widgets Google is using in customer-facing apps …