Chapter 1. Introduction

Dart is a general purpose programming language. It is a new language in the C tradition, designed to be familiar to the vast majority of programmers. The obligatory “Hello World” example illustrates how familiar Dart syntax is:

main(){
 print(`Hello World'),
}

Unless your background in programming and computer science is either extremely unusual, or lacking entirely, this code should be virtually self-explanatory. We will of course elaborate on this program and more interesting ones in the pages that follow.

Dart is purely object-oriented, class-based, optionally typed and supports mixin-based inheritance and actor-style concurrency. If these terms are unfamiliar, fear not, they will all be explained as we go along.

That said, this book is not intended as a tutorial for novices. The reader is expected to have a basic competence in computer programming.

While the bulk of this book will describe and illustrate the semantics of Dart, it also discusses the rationale for certain features. These discussions are included because, in my experience, good programmers are interested not only in what a programming language does, but why. And so, the next few sections give a very high level overview of the philosophy behind Dart. Later sections will also incorporate discussions of design decisions, alternatives and the history of the key ideas. However, if you are eager to just dive in, section 1.4 gives a quick tutorial.

And now, on with the show!

Web browsers started as a tool to display static hypertext documents. Over time, they evolved to support dynamic content. Dynamic content is computed and recomputed over time and has grown from simple animations to server-based applications such as database front-ends and store fronts for internet commerce to full-fledged applications that can run offline.

This evolution has been organic; a series of accidents, some happy and some less so, have enabled such applications to run on an infrastructure that was not really designed for this purpose.

Mobile applications pose their own challenges. These applications must conserve battery life, providing a new incentive to improve performance. Network access may be slow, costly or even absent. Mobile platforms tend to impose a particular life cycle with particular restrictions on size.

Dart is intended to provide a platform that is specifically crafted to support the kinds of applications people want to write today. As such it strives to protect the programmer from the undesirable quirks and low-level details of the underlying platform while providing easy access to the powerful facilities new platforms have to offer.

Insisting on uniform treatment of all data simplifies matters for all those involved with the language: designers, implementors and most importantly, users.

For example, collection classes can be used for all kinds of data, and no one has to be concerned with questions of autoboxing and unboxing. Such low-level details have nothing to do with the problems programmers are trying to solve in their applications; a key role of a programming language is to relieve developers of such cognitive load.

Perhaps surprisingly, adopting a uniform object model also eases the task of the system implementor.

Dart works hard to preserve this principle in several ways, though it does so imperfectly.

• Dart types are based on interfaces, not on classes. As a rule, any class can be used as an interface to be implemented by other classes, irrespective of whether the two share implementation (there are a few exceptions for core types like numbers, Booleans and strings).

• There are no final methods in Dart. Dart allows overriding of almost all methods (again, a very small number of built-in operators are exceptions).

• Dart abstracts from object representation by ensuring that all access to state is mediated by accessor methods.

• Dart’s constructors allow for caching or for producing instances of subtypes, so using a constructor does not tie one to a specific implementation.

As we discuss each of these constructs we will expand on their implications.

On the positive side, static type information provides valuable documentation to humans and computers. This information, used judiciously, makes code more readable, especially at the boundaries of libraries, and makes it easier for automated tools to support the developer.

Types simplify various analysis tasks, and in particular can help compilers improve program performance.

Adherents of static typing also argue that it helps detect programming errors.

Nothing comes for free, and adding mandatory static type checking to a programming language is no exception. There are, invariably, interesting programs that are prohibited by a given type discipline. Furthermore, the programmer’s workflow is often severely constrained by the insistence that all intermediate development states conform to a rigid type system. Ironically, the more expressive the type discipline, the more difficult it is to use and understand. Often, satisfying a type checker is a burden for programmers. Advanced type systems are typically difficult to learn and work with.

Dart provides a productive balance between the advantages and disadvantages of types. Dart is an optionally typed language, defined to mean:

• Types are syntactically optional.

• Types have no effect on runtime semantics.

Making types optional accommodates those programmers who do not wish to deal with a type system at all. A programmer who so chooses can treat Dart as an ordinary dynamically typed language. However, all programmers benefit from the extra documentation provided by any type annotations in the code. The annotations also allow tools to do a better job supporting programmers.

Dart gives warnings, not errors, about possible type inconsistencies and oversights. The extent and nature of these warnings is calibrated to be useful without overwhelming the programmer.

At the same time, a Dart compiler will never reject a program due to missing or inconsistent type information. Consequently, using types never constrains the developer’s workflow. Code that refers to declarations that are absent or incomplete may still be productively run for purposes of testing and experimentation.

The balance between static correctness and flexibility allows the types to serve the programmer without getting in the way.

The details of types in Dart are deferred until Chapter 5, where we explain the language’s type rules and explore the trade-offs alluded to above in detail.

Dart also has to be immediately recognizable to working programmers. This has dictated the choice of a syntax in the style of the C family of programming languages. It has also dictated semantic choices that are not greatly at variance with the expectations of mainstream programmers. The goal has not been radical innovation, but rather gradual, conservative progress.

As we discuss features whose semantics have been influenced by the above constraints, we shall draw attention to the design trade-offs made. Examples include the treatment of strings, numbers, the return statement and many more.

Programming language constructs are often defined in a mutually recursive fashion. It is difficult to present an orderly, sequential explanation of them, because the reader needs to know all of the pieces at once! To avoid this trap, one must first get an approximate idea of the language constructs, and then revisit them in depth. This section provides that approximation.

After reading this section, you should be able to grasp the essence of the many examples that appear in later sections of the book, without having read the entire book beforehand.

Here then, is a simple expression in Dart:

3

It evaluates, unsurprisingly, to the integer 3. And here are some slightly more involved expressions:

Click here to view code image

3 + 4
(3+4)*6
1 + 2 * 2
1234567890987654321 * 1234567890987654321

These evaluate to 7, 42, 5 and 1524157877457704723228166437789971041 respectively. The usual rules of precedence you learned in first grade apply. The last of these examples is perhaps of some interest. Integers in Dart behave like mathematical integers. They are not limited to some maximal value representable in 32 or 64 bits for example. The only limit on their size is the available memory.¹

1. Some Dart implementations may not always comply with this requirement. When Dart is translated to Javascript, Javascript numbers are sometimes used to represent integers since Javascript itself does not support an integer datatype. As a result, integers greater than 2⁵³ may not be readily available.

Dart supports not just integers but floating-point numbers, strings, Booleans and so on. Many of these built-in types have convenient syntax:

Click here to view code image

3.14159 //  A oating-point number
`a string'
"another string - both double quoted and single quoted forms are supported"
'Hello World' //  You've seen that already
true
false // All the Booleans you'll ever need
[] // an empty list
[0, 1.0, false, 'a', [2, 2.0, true, "]] // a list with 5 elements, the last of which is a list

As the above examples show, single-line comments are supported in Dart in the standard way; everything after // is ignored, up to the end of the line. The last two lines above show literal lists. The first list is empty; the second has length 5, and its last element is another literal list of length 4.

Lists can be indexed using the operator []

[1, 2, 3] [1]

The above evaluates to 2; the first element of a list is at index 0, the second at index 1 and so on. Lists have properties length and isEmpty (and many more we won’t discuss right now).

[1, 2, 3]. length // 3
[].length // 0
[].isEmpty // true
['a'].isEmpty // false

One can of course define functions in Dart. We saw our first Dart function, the main() function of “Hello World”, earlier. Here it is again

main(){
 print(`Hello World'),
}

Execution of a Dart program always begins with a call to a function called main(). A function consists of a header that gives its name and any parameters (our example has none) followed by a body. The body of main() consists of a single statement, which is a call to another function, print() which takes a single argument. The argument in this case is the string literal ‘Hello World’. The effect is to print the words “Hello World”.

Here is another function:

twice(x) => x * 2;

Here we declare twice with a parameter x. The function returns x multiplied by 2. We can invoke twice by writing

twice(2)

which evaluates to 4 as expected. The function twice consists of a signature that gives its name and its formal parameter x, followed by => followed by the function body, which is a single expression. Another, more traditional way to write twice is

twice(x) {
   return x * 2;
}

The two samples are completely equivalent, but in the second example, the body may consist of zero or more statements—in this case, a single return statement that causes the function to compute the value of x*2 and return it to the caller.

As another example, consider

Click here to view code image

max(x, y){if (x > y) return x; else return y; }

which returns the larger of its two arguments. We could write this more concisely as

max(x, y) => (x > y) ? x : y;

The first form uses an if statement, found in almost every programming language in similar form. The second form uses a conditional expression, common throughout the C family of languages. Using an expression allows us to use the short form of function declarations.

A more ambitious function is

Click here to view code image

maxElement(a) {
 var currentMax = a.isEmpty ?
   throw 'Maximal element undefined for empty array' : a[0];
 for (var i = 0; i < a.length; i++) {
   currentMax = max(a[i], currentMax);
 }
 return currentMax;
}

The function maxElement takes a list a and returns its largest element. Here we really need the long form of function declaration, because the computation will involve a number of steps that must be sequenced as a series of statements. This short function will illustrate a number of features of Dart.

The first line of the function body declares a variable named currentMax, and initializes it. Every variable in a Dart program must be explicitly declared. The variable currentMax represents our current estimate of the maximal element of the array.

In many languages, one might choose to initialize currentMax to a known value representing the smallest possible integer, typically denoted by a name like MIN INT. Mathematically, the idea of “smallest possible integer” is absurd. However, in languages where integers are limited to a fixed size representation defined by the language, it makes sense. As noted above, Dart integers are not bounded in size, so instead we initialize currentMax to the first element of the list. If the list is empty, we can’t do that, but then the argument a is invalid; the maximal element of an empty list is undefined. Consequently, we test to see if a is empty. If it is, we raise an exception, otherwise we choose the first element of the list as an initial candidate.

Exceptions are raised using a throw expression. The keyword throw is followed by another expression that defines the value to be thrown. In Dart, any kind of value can be thrown—it need not be a member of a special Exception type. In this case, we throw a string that describes the problem.

The next line begins a for statement that iterates through the list.² Every element is compared to currentMax in turn, by calling the max function defined earlier. If the current element is larger than currentMax, we set currentMax to the newly discovered maximal value.

2. We start at index 0, but we could be slightly more efficient and start at 1 in this case.

After the loop is done, we are assured that currentMax is the largest element in the list and we return it.

Until now, this tutorial has carefully avoided any mention of terms like object, class or method. Dart allows you to define functions (such as twice, max and maxElement) and variables outside of any class. However, Dart is a thoroughly object-oriented language. All the values we’ve looked at — numbers, strings, Booleans, lists and even functions themselves are objects in Dart. Each such object is an instance of some class. Operations like length, isEmpty and even the indexing operator [] are all methods on objects.

It is high time we learned how to write a class ourselves. Behold the class Point, representing points in the cartesian plane:

class Point {
 var x, y;
 Point(a, b){x = a; y = b;}
}

The above is an extremely bare-bones version of Point which we will enrich shortly. A Point has two instance variables (or fields) x and y. We can create instances of Point by invoking its constructor via a new expression:

Click here to view code image

var origin = new Point(0, 0);
var aPoint = new Point(3, 4);
var anotherPoint = new Point(3, 4);

Each of the three lines above allocates a fresh instance of Point, distinct from any other. In particular, aPoint and anotherPoint are different objects. An object has an identity, and that is what distinguishes it from any other object.

Each instance of Point has its own copies of the variables x and y, which can be accessed using the dot notation

origin.x // 0
origin.y // 0
aPoint.x // 3
aPoint.y // 4

The variables x and y are set by the constructor based on the actual parameters provided via new. The pattern of defining a constructor with formal parameters that correspond exactly to the fields of an object, and then setting those fields in the constructor, is very common, so Dart provides a special syntactic sugar for this case:

class Point {
 var x, y;
 Point(this.x, this.y);
}

The new version of Point is completely equivalent to the original, but more concise. Let’s add some behavior to Point

Click here to view code image

class Point {
 var x, y;
 Point(this.x, this.y);
 scale(factor) => new Point(x * factor, y * factor);
}

This version has a method scale that takes a scaling factor factor as an argument and returns a new point, whose coordinates are based on the receiving point’s, but scaled by factor.

Click here to view code image

aPoint.scale(2).x // 6
anotherPoint.scale(10).y // 40

Another interesting operation on points is addition

Click here to view code image

class Point {
 var x, y;
 Point(this.x, this.y);
 scale(factor) => new Point(x * factor, y * factor);
 operator +(p) => new Point(x + p.x, y + p.y);
}

Now we can write expressions like

Click here to view code image

(aPoint + anotherPoint).y // 8

The operator + on points behaves just like an instance method; in fact, it is just an instance method with a strange name and a strange invocation syntax.

Dart also supports static members. We can add a static method inside of Point to compute the distance between two points:

Click here to view code image

static distance(p1, p2) {
 var dx = p1.x - p2.x;
 var dy = p1.y - p2.y;
 return sqrt(dx * dx + dy * dy);
}

The modifier static means this method is not specific to any instance. It has no access to the instance variables x and y, as those are different for each instance of Point. The method makes use of a library function, sqrt() that computes square roots. You might well ask, where does sqrt() come from? To understand that, we need to explain Dart’s concept of modularity.

Dart code is organized into modular units called libraries. Each library defines its own namespace. The namespace includes the names of entities declared in the library. Additional names may be imported from other libraries. Declarations that are available to all Dart programs are defined in the Dart core library which is implicitly imported into all other Dart libraries. However, sqrt() is not one of them. It is defined in a library called dart:math, and if you want to use it, you must import it explicitly.

Here is a complete example of a library with an import, incorporating class Point

Click here to view code image

library points;

import 'dart:math';

class Point {
 var x, y;
 Point(this.x, this.y);
 scale(factor) => new Point(x * factor, y * factor);
 operator +(p) => new Point(x + p.x, y + p.y);
 static distance(p1, p2) {
  var dx = p1.x - p2.x;
  var dy = p1.y - p2.y;
  return sqrt(dx * dx + dy * dy);
 }
}

We have declared a library called points and imported the library dart:math. It is this import that makes sqrt available inside the points library. Now, any other library that wants to use our Point class can import points.

A key detail to note is that the import clause refers to a string ‘dart:math’. In general, imports refer to uniform resource indicators (URIs) given via strings. The URIs point the compiler at a location where the desired library may be found. The built-in libraries of Dart are always available via URIs of the form ‘dart:˙’, where ˙ denotes a specific library.

There is a lot more to Dart than what we’ve shown so far, but you should have a general idea of what Dart code looks like and roughly what it means. This background will serve you well as we go into details later in the book.

Next, we examine libraries in detail, followed by a deeper look at functions. In Chapter 5, we finally take a look at types and the role they play in Dart. We review Dart’s expressions and statements in Chapter 6. The final chapters investigate reflection and concurrency.

However, there are crucial differences. Dart introduces its own library-based encapsulation model. This differs from all three of the languages mentioned above. Smalltalk supports object-based encapsulation for fields, with methods and classes universally available. Java has a mix of class-based encapsulation and package privacy, and Javascript relies exclusively on closures for encapsulation.

Like Smalltalk and Java, Dart is class based and supports single inheritance, but it augments this with mixin-based inheritance, very similar to the model first implemented in the Strongtalk dialect of Smalltalk[2]. Because class methods in Dart are not true instance methods as in Smalltalk, but instead Java-style static methods, the models are not exactly the same.

Dart’s constructors have a syntactic similarity to those of Java, but in fact differ in critical ways. All of the above topics are discussed in the next chapter.

Dart’s approach to type checking is also very close to the one developed for Strongtalk. Types are explored exhaustively in Chapter 5.

Dart’s view of concurrency is close to the original actor model (albeit, imperative), again very different from any of the languages cited above. The success of Erlang has been a factor in the adoption of an actor model, yet unlike Erlang, Dart has a non-blocking concurrency model. Dart also has built-in support for asynchrony heavily influenced by C#. See Chapter 8 for details.