A look at Dart

Dart is a BSD-licensed programming language from Google with a mature open-source community supporting the project. It works with multiple architectures, is capable of producing native machine-code binaries, and can also produce JavaScript versions of its applications. Dart version 1.0 was released in 2013, with the most recent version, 2.8, released on June 3 (2.9 is currently in public beta). Among the open-source projects using Dart is the cross-device user-interface (UI) toolkit Flutter. We recently covered the Canonical investment in Flutter to help drive more applications to the Linux desktop, and Dart is central to that story.

Dart's syntax is a mix of concepts from multiple well-established languages including JavaScript, PHP, and C++. Further, Dart is a strongly-typed, object-oriented language, with primitive types that are implemented as classes. While Dart does have quirks, it is likely that a programmer familiar with the aforementioned languages will find getting started with Dart to be relatively easy. Included in the language are useful constructs like Lists (arrays), Sets (unordered collections), and Maps (key/value pairs).

Beyond the language constructs, the Dart core libraries provide additional support for features like asynchronous programming, HTML manipulation, and converters to work with UTF-8 and JSON.

Dart compilation targets

To learn about Dart's compilation features, we need something to compile; for purposes of an example, it was easy enough to write a small Dart application that calculates and displays the Fibonacci sequence recursively:

    /* Application entry point, just like C */
    void main() {
        int totalTerms = 45;
        String output = "";

        for(int i = 1; i <= totalTerms; i++) {
            output += fibonacci(i).toString() + ", ";
        }

        print(output + "...");
    }

    /* A compact syntax for the recursive fibonacci algorithm */
    int fibonacci(int n) => n <= 2 ? 1 : fibonacci(n - 2) + fibonacci(n - 1);

In Dart, like in C, the main() function is the entry point into the application. It is worth noting, however, the compact JavaScript-inspired syntax of the fibonacci() function. The function uses Dart arrow syntax combined with a conditional expression to implement the algorithm. For reference, below is a more verbose version of the same fibonacci() function:

    int fibonacci(int n) {
        if(n <= 2) {
            return 1;
        }

        return fibonacci(n - 2) + fibonacci(n - 1);
    }

The language provides many options for executing a Dart program. The most straightforward approach is from the command line using the dart command to execute the program using the Dart virtual machine (VM). Like other languages, Dart's VM implements just-in-time (JIT) compilation of Dart code into native machine code. Here's the output of the preceding example:

    $ dart fibonacci.dart
    1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610,
    987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368,
    75025, 121393, 196418, 317811, 514229, 832040, 1346269,
    2178309, 3524578, 5702887, 9227465, 14930352, 24157817,
    39088169, 63245986, 102334155, 165580141, 267914296,
    433494437, 701408733, 1134903170, ...

As an alternative to the VM, Dart can also be compiled into native machine code using the dart2native command. While it can accurately be described as compiling to native machine code, there are some differences when comparing Dart to other compiled languages, such as C. Because of the nature of the Dart language, not all code can necessarily be compiled to native machine code. There are multiple reasons for this; one example being that a Dart application may not be able to determine the type of a given variable in certain code blocks until runtime. In that case, those code blocks cannot take advantage of compilation and must be interpreted by the VM as bytecode. Thus, even compiled Dart applications still require a runtime in order to address those issues.

By default, dart2native will create a standalone binary of the application with the runtime bundled in. Alternatively, dart2native can create what is known as an ahead-of-time (AOT) binary. These binaries do not include an embedded runtime and cannot be executed directly. They can, however, be executed if a runtime environment is provided externally — such as by using the dartaotruntime command. Alternatively, AOT binaries can be used in Dart-powered cloud services where a runtime is provided by the service.

Finally, Dart can also "compile" to JavaScript (known as transpiling) using the dart2js command. The documentation indicates that the dart2js command is best suited for a production build, since the entire application is transpiled into a single optimized JavaScript file.

For development purposes, the documentation recommends the dartdevc command. Unlike dart2js, the dartdevc command supports incremental transpilation and produces a modular version of the application with multiple separate JavaScript files. This allows the developer to only transpile the changes in the application during development, saving considerable time otherwise wasted waiting to transpile the entire code base. This tool is often used in conjunction with a development web server that keeps the transpiled JavaScript up-to-date in real time as the underlying Dart code is edited. For developing browser-based Dart applications, Dart provides a development web server available through the webdev command. This tool handles rebuilding the application to JavaScript as it is being developed using dart2devc automatically.

Getting into Dart

To try Dart coding out yourself, there are a few options. Since Dart can be transpiled to JavaScript, the easiest approach is to simply use the project's provided browser-based runtime. For local installation of the SDK, Dart's project website provides instructions — including an APT package repository for Linux, Windows installation via Chocolatey, and macOS installation via Homebrew.

Beyond the Dart core libraries that ship with the language, there is an open-source community also providing libraries. The most prominent collection is a repository of packages called pub.dev that can be used in application development. To manage these libraries Dart uses a YAML-based dependencies file called pubspec.yaml stored in the project root directory. Below is an example pubspec.yaml for a project, where we define a dependency on the basic_utils package found on pub.dev:

    name: LWN-Example
    dependencies:
      basic_utils: 2.5.5

To download and install all of the dependencies for the application, Dart provides the pub command. All that is needed to resolve and install the dependencies on a system is to run pub get from the root directory of the project.

By default, these dependencies are assumed to come from the Dart pub.dev repository. For dependencies that are not available in that repository, Dart supports Git dependencies that allow them to be taken from Git repositories. Like the PHP Composer package tool, pub get produces a matching pubspec.lock file in the project's root the first time it is executed that captures the exact version of a dependency that the project is using. Subsequent calls to pub get will default to using this file over pubspec.yaml, ensuring the version of the library being used is the correct one for the project. To upgrade a project's dependencies to their latest versions, use the pub upgrade command.

Below is a brief demonstration of the use of packages (as well as more of the language itself). In this example, we construct a simple Dart command-line application to determine whether the provided string is an email address. This takes advantage of the basic_utils package mentioned earlier that includes, among other things, the EmailUtils::isEmail() method:

    import 'package:basic_utils/basic_utils.dart';

    void main(List<String> arguments)
    {
        if (EmailUtils.isEmail(arguments[0])) {
            print("It's an email!");
        } else {
            print("Not an email.");
        }
    }

As shown, we import the basic_utils package using the import statement. The package: prefix of that statement indicates the import is coming from an outside package, rather than from somewhere in the project itself. The statement imports all of the classes defined in the basic_utils package, including the EmailUtils class we use to do the email address validation.

In this example, we have specified an argument to our main() entry point function. This argument is a List (array) of strings (String type) with the name arguments. When this parameter is provided in the declaration of the main() function, Dart will automatically populate it with the command-line arguments given to the application when executed. Since a List is Dart's version of a numerically-indexed array, arguments[0] references the first command-line argument provided (note that in other languages, index 0 is typically the name of the command executed):

    $ dart package-demo.dart someone@example.com
    It's an email!

Wrapping up

There is a lot to like about Dart as a language to write more traditional "applications" in — it is what the language was designed to do. Developers can write applications in any language, and they do, but each language was designed considering a niche it is looking to fill. Dart describes itself on its project page as "a client-optimized language for fast apps on any platform", and specifically as a "language specialized around the needs of user interface creation". Dart stands apart in that sense, as not many languages can claim they were designed with that specific combination of needs in mind.

It is safe to say that we have barely scratched the surface of the capabilities of Dart in this article. Here, we have given a glimpse of the language, with the hope of helping decide if it is worth further examination. The tour of the language and tutorials found in the Dart documentation will be helpful for getting started.