Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
The Dart programming language
Bracha G., Addison-Wesley Professional, London, UK, 2016. 224 pp. Type: Book (978-0-321927-70-5)
Date Reviewed: Jan 20 2017

Dart is a general-purpose, object-oriented, optionally typed programming language designed to be easy to learn, easy to use, and easy to run efficiently in multi-core, distributed environments, including the World Wide Web. The Dart programming language describes Dart from the perspective of the language theorist and language designer rather than the application programmer.

In Dart, everything is an object. Class inheritance is limited to single inheritance, and multiple inheritance is allowed through mixins. To allow processing in distributed environments, Dart provides facilities for serialization and for asynchronous processing.

Dart’s salient feature, however, is optional typing. A developer is never required to specify a type, although type annotations can be helpful for documentation and for developing language checking tools. The Dart type system is deliberately unsound. Dart provides a check mode, where type annotations are treated as assertions that may generate warnings, and a production mode where assertions are disabled. The newest version of Dart, announced after this book was published, includes an optionally strong checking mode. A more detailed explanation of the Dart type system would take this review too far afield; consult Bracha’s book or the Dart language website [1] for additional information.

The book is relatively small: nine chapters, a bibliography, and the index take up only 201 pages. The first six chapters cover the basics of the language--language design principles and constraints, objects, interfaces, classes, mixins, libraries, functions, types, expressions, and statements. Of these, chapter 5, on types, requires the most attention: Bracha makes a compelling case in explaining why the Dart type system not only works, but provides significant advantages for the language and for the application developer.

Chapters 7 and 8, on reflection, asynchrony, and isolates, cover the features needed for distributed environments. In chapter 7, Bracha includes the code to implement a basic serialization algorithm, the corresponding deserialization, and an illustration using a parser combinator. In chapter 8, he illustrates asynchronous client-server communication. In both cases, Bracha makes it clear that the code shown is for pedagogical purposes only and explains why it would be inadequate for real-life applications.

In chapter 9, “Conclusion,” Bracha summarizes Dart as it is now, how it might change in the future, and how it compares to or contrasts with other languages and several theoretical issues. The honest, incisive observations and opinions in this section will be of special interest to readers who design or upgrade programming languages and programming environments.

The bibliography, reflecting the tone of the book, is excellent but highly academic. Sadly, I must report that the index has some important entries missing, and that others have missing page references. I recommend annotating the index as you go along.

The book is notable for presenting Dart in a straightforward, unvarnished fashion. Bracha describes the goals and choices that drove the language design and the rationale for the compromises made. At various points, he also lists the influences from, and the similarities and differences with, many other programming languages.

This book will be a valuable resource to computer science students and to programming language theorists. For many developers, however, this would not be a good first book to learn Dart programming--but it would be a great one to study once they have some experience using the language. Depending on the reader’s theoretical knowledge, the book may be easy to read, demanding, or frankly difficult. At any rate, I enjoyed it and recommend it.

Dart has a sophisticated and growing set of associated tools and libraries. The developer can choose from among several programming environments. Google, where the language was created, uses it to develop large web-based applications. Still young and evolving, Dart is worth getting acquainted with. For the right audience, Bracha’s The Dart programming language is an excellent introduction and reference.

More reviews about this item: Amazon

Reviewer:  Edgar R. Chavez Review #: CR145015 (1704-0199)
1) Dart, https://www.dartlang.org/ (01/02/2017).
Bookmark and Share
  Reviewer Selected
Featured Reviewer
 
 
Object-Oriented Languages (D.3.2 ... )
 
 
Language Constructs and Features (D.3.3 )
 
 
Object-Oriented Programming (D.1.5 )
 
Would you recommend this review?
yes
no
Other reviews under "Object-Oriented Languages": Date
Understanding object-oriented: a unifying paradigm
Korson T., McGregor J. (ed) Communications of the ACM 33(9): 40-60, 1990. Type: Article
May 1 1991
From Fortran and Algol to object-oriented languages
Wilkes M. Communications of the ACM 36(7): 21-23, 1993. Type: Article
Nov 1 1994
Object-oriented programming with prototypes
Blaschek G., Springer-Verlag New York, Inc., New York, NY, 1994. Type: Book (9780387564692)
Feb 1 1995
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy