Dart (programming language)

Dart was unveiled at the GOTO conference in Aarhus, Denmark, October 10–12, 2011.[9] Lars Bak and Kasper Lund founded the project.[10] Dart 1.0 was released on November 14, 2013.[11]

Dart had a mixed reception at first. Some criticized the Dart initiative for fragmenting the web because of plans to include a Dart VM in Chrome. Those plans were dropped in 2015 with the Dart 1.9 release. Focus changed to compiling Dart code to JavaScript.[12]

Dart 2.0 was released in August 2018 with language changes including a type system.[13]

Dart 2.6 introduced a new extension, dart2native. This extended native compilation to the Linux, macOS, and Windows desktop platforms.[14] Earlier developers could create new tools using only Android or iOS devices. With this extension, developers could deploy a program into self-contained executables. The Dart SDK doesn't need to be installed to run these self-contained executables.[15] The Flutter toolkit integrates Dart, so it can compile on small services like backend support.[16][17]

Dart 3.0 changed the type system to require sound null safety. This release included new features like records, patterns,[18] and class modifiers.[19] Dart 3 also previewed support for Web Assembly.[20]

Dart released the 5th edition of its language specification on April 9, 2021.[21] This covers all syntax through Dart 2.10. A draft of the 6th edition includes all syntax through 2.13.[22] Accepted proposals for the specification and drafts of potential features can be found in the Dart language repository on GitHub.[23]

ECMA International formed technical committee, TC52,[24] to standardize Dart. EMCA approved the first edition of the Dart language specification as ECMA-408[25] in July 2014 at its 107th General Assembly.[26] Subsequent editions were approved in December 2014.,[27] June 2015, and December 2015.[25]

The Dart software development kit (SDK) ships with a standalone Dart runtime. This allows Dart code to run in a command-line interface environment. The SDK includes tools to compile and package Dart apps.[28] Dart ships with a complete standard library allowing users to write fully working system apps like custom web servers.[29]

Developers can deploy Dart apps in six ways:

To achieve concurrency, Dart uses isolated, independent workers that do not share memory, but use message passing,[43] similarly to Erlang processes (also see actor model). Every Dart program uses at least one isolate, which is the main isolate. Since Dart 2, the Dart web platform no longer supports isolates, and suggests developers use Web Workers instead.[44]

Starting with Dart 2.12, Dart introduced sound null safety.[45] This serves as a guarantee that variables cannot return a null value unless it has explicit permission. Null safety prevents the developer from introducing null pointer exceptions, a common, but difficult to debug, error. With Dart 3, all code must follow sound null safety.

Snapshot files, a core part of the Dart VM, store objects and other runtime data.[43]

Script snapshots

Dart programs can be compiled into snapshot files containing all of the program code and dependencies preparsed and ready to execute, allowing fast startups.

Full snapshots

The Dart core libraries can be compiled into a snapshot file that allows fast loading of the libraries. Most standard distributions of the main Dart VM have a prebuilt snapshot for the core libraries that is loaded at runtime.

Object snapshots

Dart uses snapshots to serialize messages that it passes between isolates. As a very asynchronous language, Dart uses isolates for concurrency.[46] An object generates a snapshot, transfers it to another isolate, then the isolate deserializes it.

On November 18, 2011, Google released Dart Editor, an open-source program based on Eclipse components, for macOS, Windows, and Linux-based operating systems.[47] The editor supports syntax highlighting, code completion, JavaScript compiling, running web and server Dart applications, and debugging.

On August 13, 2012, Google announced the release of an Eclipse plugin for Dart development.[48]

On April 18, 2015, Google retired the Dart Editor in favor of the JetBrains integrated development environment (IDE).[49] Android Studio, IntelliJ IDEA, PyCharm, PhpStorm and WebStorm support a Dart plugin.[50] This plugin supports many features such as syntax highlighting, code completion, analysis, refactoring, debugging, and more. Other editors include plugins for Dart[51] including Sublime Text,[52] Atom,[53] Emacs,[54] Vim[55] and Visual Studio Code.[56]

The Dart DevTools, written in Dart,[63] include debugging and performance tools.

Google introduced Flutter for native app development. Built using Dart, C, C++ and Skia, Flutter is an open-source, multi-platform app UI framework. Prior to Flutter 2.0, developers could only target Android, iOS and the web. Flutter 2.0 released support for macOS, Linux, and Windows as a beta feature.[64] Flutter 2.10 released with production support for Windows[65] and Flutter 3 released production support for all desktop platforms.[66] It provides a framework, widgets, and tools. This framework gives developers a way to build and deploy mobile, desktop, and web apps.[67] Flutter works with Firebase[68] and supports extending the framework through add-ons called packages. These can be found on their package repository, pub.dev.[69] JetBrains also supports a Flutter plugin.[70]

A Hello, World! example:

void main() {
  print('Hello, World!');
}

A function to calculate the nth Fibonacci number:

void main() {
  var i = 20;
  print('fibonacci($i) = ${fibonacci(i)}');
}

/// Computes the nth Fibonacci number.
int fibonacci(int n) {
  return n < 2 ? n : (fibonacci(n - 1) + fibonacci(n - 2));
}

A simple class:

// Import the math library to get access to the sqrt function.
// Imported with `math` as name, so accesses need to use `math.` as prefix.
import 'dart:math' as math;

// Create a class for Point.
class Point {

  // Final variables cannot be changed once they are assigned.
  // Declare two instance variables.
  final num x, y;

  // A constructor, with syntactic sugar for setting instance variables.
  // The constructor has two mandatory parameters.
  Point(this.x, this.y);

  // A named constructor with an initializer list.
  Point.origin()
      : x = 0,
        y = 0;

  // A method.
  num distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return math.sqrt(dx * dx + dy * dy);
  }
  
  // Example of a "getter".
  // Acts the same as a final variable, but is computed on each access.
  num get magnitude => math.sqrt(x * x + y * y);

  // Example of operator overloading
  Point operator +(Point other) => Point(x + other.x, y + other.y);
  // When you instantiate a class such as Point in Dart 2+, new is 
  // an optional word
}

// All Dart programs start with main().
void main() {
  // Instantiate point objects.
  var p1 = Point(10, 10);
  print(p1.magnitude);
  var p2 = Point.origin();
  var distance = p1.distanceTo(p2);
  print(distance);
}

Dart belongs the ALGOL language family.[71] Its members include C, Java, C#, JavaScript, and others.

The method cascade syntax was adopted from Smalltalk.[72] This syntax provides a shortcut for invoking several methods one after another on the same object.

Dart's mixins were influenced by Strongtalk[73][74] and Ruby.

Dart makes use of isolates as a concurrency and security unit when structuring applications.[75] The Isolate concept builds upon the Actor model implemented in Erlang.[76]

In 2004, Gilad Bracha (who was a member of the Dart team) and David Ungar first proposed Mirror API for performing controlled and secure reflection in a paper.[77] The concept was first implemented in Self.

• Google Web Toolkit
• TypeScript, a strongly-typed programming language that transpiles to JavaScript
• Flutter, an open-source UI software development kit for cross-platform applications

• Official website
• DartPad