Dart в действии

Dart в действии

Крис Баккет

Dart in Action

CHRIS BUCKETT

M A N N I N G

Shelter Island

Dart в действии

Москва, 2023

Крис Баккет

С предисловием Сета Лэдда

2-е издание, электронное

УДК 004Dart
ББК 32.973-018.2
Б19

Б19
Бакетт, Крис.
Dart в действии / К. Бакетт ; пер. с англ. — 2-е изд., эл. — 1 файл pdf : 
530 с. — Москва : ДМК Пресс, 2023. — Систем. требования: Adobe Reader 
XI либо Adobe Digital Editions 4.5 ; экран 10". — Текст : электронный.
ISBN 978-5-89818-314-1
Dart — язык программирования для разработки веб-приложений, созданный 
компанией Google. Он обладает современными объектно-ориентированными средствами, 
как Java или C#, не отказываясь при этом от свойственных JavaScript динамичности 
и ориентированности на функциональное программирование. Написанные 
на Dart приложения транслируются в JavaScript, но могут исполняться и непосредственно 
в браузерах, поддерживающих Dart. В комплекте с Dart поставляются библиотеки 
и инструментальные средства промышленного качества. На Dart могут 
быть написаны как клиентская, так и серверная часть приложения, что упрощает 
процесс разработки.
В этой книге вы познакомитесь с языком Dart и научитесь использовать его для 
создания приложений, работающих в браузере, — в настольной или мобильной ОС. 
Это не просто учебное пособие по языку, довольно быстро автор переходит к техническим 
аспектам работы с Dart. На большинство вопросов, возникающих при чтении, 
тут же даются ответы!
Издание предназначено веб-программистам разной квалификации, в том числе 
малознакомым с объектно-ориентированным программированием.

УДК 004Dart 
ББК 32.973-018.2

Электронное издание на основе печатного издания: Dart в действии / К. Бакетт ; пер. с англ. — 
Москва : ДМК Пресс, 2013. — 528 с. — ISBN 978-5-94074-918-9. — Текст : непосредственный.

Все права защищены. Любая часть этой книги не может быть воспроизведена в какой бы то ни было 
форме и какими бы то ни было средствами без  письменного разрешения владельцев авторских прав.
Материал, изложенный в данной книге, многократно проверен. Но поскольку вероятность технических 
ошибок все равно существует, издательство не может гарантировать абсолютную точность и правильность 
приводимых сведений. В связи с этим издательство не несет ответственности за возможные ошибки, связанные 
с использованием книги.

В соответствии со ст. 1299 и 1301 ГК РФ при устранении ограничений, установленных техническими средствами 
защиты авторских прав, правообладатель вправе требовать от нарушителя возмещения убытков или выплаты компенсации.


ISBN 978-5-89818-314-1
© 2013 by Manning Publications Co.
© Оформление, перевод ДМК Пресс, 2013

Содержание

Предисловие ....................................................................... 14
Вступление .......................................................................... 16
Благодарности ................................................................... 18
Об этой книге ...................................................................... 20
Об иллюстрации на обложке ........................................... 25

ЧАСТЬ I. ВВЕДЕНИЕ В DART ............................................. 26

Глава 1. Здравствуй, Dart ................................................ 27
1.1. Что такое Dart? ................................................................. 27
1.1.1. Знакомый синтаксис помогает в освоении языка ...... 29
1.1.2. Архитектура одностраничного приложения ............... 30
1.2. Первый взгляд на язык Dart ............................................... 32
1.2.1. Строковая интерполяция ........................................... 32
1.2.2. Факультативные типы в действии .............................. 34
1.2.3. Традиционная структура на основе классов............... 36
1.2.4. Определение подразумеваемого интерфейса ........... 38
1.2.5. Фабричные конструкторы для предоставления 
реализации по умолчанию .................................................. 39
1.2.6. Библиотеки и область видимости .............................. 40
1.2.7. Функции как полноценные объекты ........................... 43
1.2.8. Параллелизм с помощью изоляторов ........................ 45
1.3. Веб-программирование на языке Dart .............................. 46
1.3.1. dart:html: удобная библиотека для работы 
с моделью DOM браузера ................................................... 47
1.3.2. Dart и HTML5 ............................................................. 48
1.4. Инструментальная экосистема Dart .................................. 50
1.4.1. Редактор Dart ............................................................ 50
1.4.2. Виртуальная машина Dart .......................................... 51
1.4.3. Dartium ...................................................................... 51
1.4.4. dart2js: конвертер Dart в JavaScript ............................ 51

Содержание

1.4.5. Управление пакетами с помощью pub ....................... 52
1.5. Резюме ............................................................................. 53

Глава 2. Программа «Здравствуй, мир» на Dart .......... 54
2.1. ВМ Dart для командных приложений ................................. 55
2.2. Программа «Здравствуй, мир» в редакторе Dart ............... 57
2.2.1. Знакомство с инструментами, встроенными 
в Редактор Dart Editor ......................................................... 58
2.2.2. Dart-скрипты и HTML-файлы ..................................... 61
2.2.3. Запуск приложения «Здравствуй, мир» в Dartium ....... 62
2.2.4. Использование dart2js для конвертации 
в JavaScript ......................................................................... 63
2.2.5. Генерация документации с помощью dartdoc ............ 66
2.2.6. Отладка Dart-кода с помощью точек останова ........... 66
2.3. Импорт библиотек для работы с пользовательским 
интерфейсом в браузере ......................................................... 68
2.3.1. Импорт библиотек Dart .............................................. 69
2.3.2. Доступ к элементам DOM с помощью dart:html .......... 70
2.3.3. Динамическое добавление новых элементов 
на страницу ........................................................................ 71
2.4. Резюме ............................................................................. 72

Глава 3. Создание и тестирование 
Dart-приложения ............................................................... 74
3.1. Конструирование пользовательского интерфейса 
с помощью dart:html ................................................................ 75
3.1.1. Начальный HTML-файл .............................................. 76
3.1.2. Создание элементов с помощью dart:html ................. 77
3.1.3. Создание экземпляра Element из фрагмента HTML ... 78
3.1.4. Создание элементов по имени тега ........................... 80
3.1.5. Добавление элементов в HTML-документ .................. 82
3.2. Добавление интерактивности с помощью событий 
браузера ................................................................................. 86
3.2.1. Добавление предмета в список по нажатии кнопки ... 86
3.2.2. Применение гибкого синтаксиса функций в Dart 
для обработки событий ....................................................... 87
3.2.3. Реагирование на события браузера........................... 90
3.2.4. Рефакторинг прослушивателя событий 
для повторного использования ........................................... 91

Содержание

3.2.5. Запрос HTML-элементов в dart:html .......................... 92
3.3. Инкапсуляция структуры и функциональности 
с помощью классов .................................................................... 95
3.3.1. Классы в Dart не таят неожиданностей ...................... 96
3.3.2. Конструирование класса PackItem ............................. 97
3.3.3. Инкапсуляция функциональности с помощью 
методов чтения и установки ................................................ 99
3.4. Автономное тестирование программы ............................ 103
3.4.1. Создание автономных тестов .................................. 105
3.4.2. Определение ожидаемых результатов теста ........... 106
3.4.3. Создание пользовательского сравнивателя ............ 107
3.5. Резюме ........................................................................... 109

ЧАСТЬ II. ЯЗЫК DART ....................................................... 111

Глава 4. Функции и замыкания ..................................... 112

4.1. Функции в Dart ................................................................ 113
4.1.1. Тип возвращаемого функцией значения 
и ключевое слово return .................................................... 116
4.1.2. Передача функции данных с помощью 
параметров ...................................................................... 119
4.2. Функции как полноценные объекты ................................. 126
4.2.1. Объявления локальных функций .............................. 128
4.2.2. Определение строгого типа функции ...................... 134
4.3. Замыкания ...................................................................... 137
4.4. Резюме ........................................................................... 140

Глава 5. Библиотеки и ограничение доступа ............. 142
5.1. Определение и импорт библиотеки ................................ 143
5.1.1. Определение библиотеки с помощью ключевого 
слова library ...................................................................... 145
5.1.2. Импорт библиотек ................................................... 147
5.2. Сокрытие функциональности путем ограничения 
доступа к частям библиотеки ................................................ 155
5.2.1. Ограничение доступа в классах ............................... 157
5.2.2. Использование закрытых функций в библиотеках.... 162
5.3. Организация исходного кода библиотеки ....................... 163
5.3.1. Ключевые слова part и part of ................................... 164
5.4. Упаковка библиотек ........................................................ 168

Содержание

5.5. Скрипты – это исполняемые библиотеки ........................ 171
5.6. Резюме ........................................................................... 173

Глава 6. Классы и интерфейсы ..................................... 175
6.1. Определение простого класса ........................................ 176
6.1.1. Программирование относительно интерфейса 
класса............................................................................... 177
6.1.2. Формализация интерфейса путем явного 
его определения ............................................................... 180
6.1.3. Реализация нескольких интерфейсов ...................... 181
6.1.4. Объявление акцессоров свойств ............................. 182
6.2. Конструирование классов и интерфейсов ....................... 184
6.2.1. Конструирование экземпляров класса .................... 185
6.2.2. Проектирование и использование классов 
с несколькими конструкторами ......................................... 187
6.2.3. Использование фабричных конструкторов 
для создания экземпляров абстрактных классов .............. 187
6.2.4. Применение фабричных конструкторов 
для повторного использования объектов .......................... 190
6.2.5. Использование статических методов и свойств 
совместно с фабричными конструкторами ....................... 191
6.3. Создание константных классов с неизменяемыми 
полями .................................................................................. 194
6.3.1. Финальные значения и свойства ............................. 195
6.3.2. Блок инициализации конструктора .......................... 195
6.3.3. Использование ключевого слова const 
для создания константного конструктора ......................... 196
6.4. Резюме ........................................................................... 197

Глава 7. Расширение классов и интерфейсов .......... 199
7.1. Расширение классов с помощью наследования .............. 200
7.1.1. Наследование класса .............................................. 201
7.1.2. Наследование конструкторов .................................. 203
7.1.3. Переопределение методов и свойств ...................... 205
7.1.4. Включение абстрактных классов в иерархию 
наследования ................................................................... 206
7.2. Все является объектом ................................................... 210
7.2.1. Проверка отношения «является» Object ................... 210
7.2.2. Использование отношения «является» 
применительно к Object .................................................... 212

Содержание

7.2.3. Использование метода toString(), 
унаследованного от класса Object .................................... 213
7.2.4. Перехват обращений к методу noSuchMethod() ....... 215
7.2.5. Прочая функциональность класса Object ................. 218
7.3. Знакомство с типом dynamic ........................................... 219
7.3.1. Использование аннотации типа dynamic .................. 220
7.4. Резюме ........................................................................... 221

Глава 8. Классы коллекций ............................................ 223
8.1. Работа с коллекциями данных ......................................... 224
8.1.1. Коллекции объектов ................................................ 226
8.1.2. Использование конкретных реализаций 
интерфейса Collection ....................................................... 230
8.1.3. Создание специализированных коллекций 
с помощью обобщенных типов .......................................... 233
8.1.4. Хранение списков пар ключ–значение 
в обобщенных словарях .................................................... 237
8.2. Создание обобщенных классов ...................................... 242
8.2.1. Определение обобщенного класса .......................... 242
8.2.2. Использование своего обобщенного класса............ 244
8.2.3. Ограничения на параметрические типы ................... 245
8.3. Перегрузка операторов .................................................. 246
8.3.1. Перегрузка операторов сравнения .......................... 247
8.3.2. Неожиданное применение перегрузки 
операторов ....................................................................... 249
8.3.3. Перегрузка операторов доступа по индексу ............ 249
8.4. Резюме ........................................................................... 252

Глава 9. Асинхронное программирование 
с применением обратных вызовов и будущих 
значений ............................................................................ 254
9.1. Почему веб-приложение должно быть асинхронным ....... 256
9.1.1. Преобразование приложения в асинхронное .......... 259
9.2. Использование обратных вызовов в асинхронном 
программировании ............................................................... 263
9.2.1. Добавление асинхронных обратных вызовов 
в Лотерею Dart .................................................................. 265
9.2.2. Ожидание завершения всех асинхронных 
обратных вызовов перед продолжением .......................... 266

Содержание

9.2.3. Вложенные обратные вызовы как средство 
управления порядком асинхронного выполнения ............. 269
9.3. Знакомство с типами Future и Completer ......................... 271
9.3.1. Передача будущих значений из одного места 
программы в другое ......................................................... 274
9.3.2. Упорядочение асинхронных вызовов путем 
сцепления будущих значений ........................................... 275
9.3.3. Ожидание завершения всех запущенных 
операций получения будущих значений ............................ 276
9.3.4. Преобразование обычных значений в будущие ....... 278
9.4. Автономное тестирование асинхронных API .................... 280
9.4.1. Тестирование асинхронных функций обратного 
вызова .............................................................................. 282
9.4.2. Тестирование будущих значений ............................. 283
9.5. Резюме ........................................................................... 285

ЧАСТЬ III. КЛИЕНТСКИЕ DART-ПРИЛОЖЕНИЯ ........... 287

Глава 10. Создание веб-приложения на Dart ............ 288

10.1. Структура одностраничного веб-приложения ............... 289
10.1.1. Приложение DartExpense – постановка задачи ...... 290
10.1.2. Структура Dart-приложения ................................... 293
10.1.3. Поток выполнения в Dart-приложении ................... 296
10.2. Конструирование пользовательского интерфейса 
с помощью dart:html .............................................................. 299
10.2.1. Интерфейс Element ............................................... 299
10.2.2. Конструкторы элементов в действии ..................... 303
10.2.3. Организация взаимодействия 
с представлениями и элементами .................................... 305
10.2.4. Построение простой обобщенной сетки ................ 309
10.3. Обработка браузерных событий с помощью dart:html ... 313
10.3.1. Управление порядком прохождения события 
в браузере ........................................................................ 315
10.3.2. Наиболее распространенные типы событий .......... 317
10.4. Резюме ......................................................................... 319

Глава 11. Навигация и локальное хранение 
данных ................................................................................ 321
11.1. Интеграция навигации с браузером .............................. 323

Содержание

11.1.1. Применение функции pushState() 
для добавления элементов в браузерную историю 
навигации ......................................................................... 324
11.1.2. Подписка на событие popState .............................. 326
11.2. Использование куков браузера для повышения 
удобства работы ................................................................... 329
11.2.1. Сохранение данных в куке ..................................... 330
11.2.2. Чтение данных из кука ........................................... 332
11.3. Локальное хранение данных с помощью 
Web Storage API ..................................................................... 334
11.3.1. Преобразование объектов Dart в формат JSON ..... 335
11.3.2. Преобразование JSON-строк в Dart-объекты ........ 340
11.3.3. Сохранение данных в браузере ............................. 341
11.4. Резюме ......................................................................... 346

Глава 12. Взаимодействие с другими системами 
и языками .......................................................................... 348

12.1. Взаимодействие с JavaScript ........................................ 349
12.1.1. Отправка данных из Dart в JavaScript ..................... 352
12.1.2. Получение в JavaScript данных, посланных 
из Dart .............................................................................. 355
12.1.3. Отправка данных из JavaScript в Dart ..................... 358
12.2. Взаимодействие с внешними серверами ...................... 361
12.2.1. Правило одного домена......................................... 363
12.2.2. Использование JSONP для запроса данных 
у внешнего сервера .......................................................... 364
12.3. Построение допускающих установку браузерных 
приложений, не требующих сервера ..................................... 367
12.3.1. Применение технологии AppCache для запуска 
приложений в автономном режиме ................................... 368
12.3.2. Создание пакета приложения, допускающего 
установку в Chrome ........................................................... 373
12.4. Резюме ......................................................................... 377

ЧАСТЬ IV. DART НА СТОРОНЕ СЕРВЕРА ....................... 379

Глава 13. Работа с файлами и протоколом HTTP 
на сервере ......................................................................... 380
13.1. Запуск серверного Dart-скрипта ................................... 381

Содержание

13.1.1. Доступ к аргументам командной строки ................ 384
13.1.2. Доступ к файлам и папкам с помощью dart:io......... 386
13.2. Обслуживание HTTP-запросов от браузера................... 393
13.2.1. Класс HttpServer .................................................... 395
13.2.2. Передача статических файлов по HTTP .................. 397
13.3. REST API для клиентов .................................................. 399
13.3.1. Отправка содержимого каталога в формате 
JSON ................................................................................ 402
13.3.2. Отправка содержимого файла в формате JSON .... 403
13.3.3. Добавление пользовательского интерфейса 
на стороне клиента ........................................................... 404
13.4. Резюме ......................................................................... 409

Глава 14. Отправка, синхронизация 
и сохранение данных ...................................................... 410
14.1. Передача приложения DartExpense с сервера ............... 411
14.2. Использование веб-сокетов для организации 
двусторонней связи .............................................................. 411
14.2.1. Соединение через веб-сокет на стороне 
клиента ............................................................................. 414
14.2.2. Обработка подключения через веб-сокет 
на сервере ........................................................................ 416
14.2.3. Использование веб-сокетов для межбраузерной 
синхронизации ................................................................. 419
14.3. Сохранение данных в базе CouchDB с помощью 
класса HttpClient .................................................................... 426
14.3.1. Краткое введение в CouchDB ................................ 427
14.3.2. Совместное использование модельного 
класса Expense в коде клиента и сервера .......................... 430
14.3.3. Добавление поддержки сохранения данных 
на сервере ........................................................................ 431
14.4. Резюме ......................................................................... 437

Глава 15. Организация параллелизма 
с помощью изоляторов .................................................. 438
15.1. Использование изоляторов как единиц работы ............. 439
15.1.1. Создание изолятора .............................................. 440
15.1.2. Односторонняя связь с изолятором ...................... 442
15.1.3. Двусторонняя связь с изолятором ......................... 446

Содержание

15.2. Динамическая загрузка кода ......................................... 452
15.2.1. Создание изолятора для загружаемого файла....... 454
15.2.2. Определение динамически загружаемого 
исходного файла .............................................................. 455
15.3. Запуск нескольких исполнителей .................................. 457
15.4. Резюме ......................................................................... 463

Приложение A. Справочное руководство 
по языку ............................................................................. 464
A.1. Объявления переменных ................................................ 464
A.1.1. Объявление переменных с ключевым словом var 
или именем типа ............................................................... 465
A.1.2. Объявление финальных (доступных только 
для чтения) переменных ................................................... 466
A.1.3. Синтаксис литералов .............................................. 466
A.1.4. Обобщенные списки и словари ............................... 474
A.2. Функции ......................................................................... 475
A.2.1. Длинная синтаксическая форма .............................. 477
A.2.2. Короткая синтаксическая форма ............................. 477
A.2.3. Параметры функции ................................................ 478
A.2.4. Функции как полноценные объекты ......................... 479
A.3. Управление потоком выполнения и итерирование .......... 482
A.3.1. Ветвление потока выполнения ................................ 482
A.3.2. Циклы и итерирование ............................................ 487

Приложение B. Определение классов 
и библиотек ....................................................................... 491
B.1. Классы и интерфейсы..................................................... 491
B.1.1. Определение классов ............................................. 491
B.1.2. Наследование классов ............................................ 502
B.1.3. Абстрактные классы ................................................ 505
B.1.4. Неявные интерфейсы .............................................. 506
B.1.5. Статические свойства и методы .............................. 508
B.2. Библиотеки и ограничение доступа ................................ 509
B.2.1. Определение библиотек ......................................... 509
B.2.2. Ограничение доступа к элементам библиотеки ....... 510

Предметный указатель ................................................... 512

Предисловие

Услышав, что мы приступаем  к работе над Dart – структурным, масштабируемым 
языком с быстрой виртуальной машиной, развитым 
редактором и компилятором на JavaScript, я поначалу не поверил. 
«Быть может, именно этот проект сделает веб-программирование 
проще для таких разработчиков, как я сам?» – задавался я вопросом 
в надежде получить утвердительный ответ. Имея опыт работы со 
структурными языками и мощными инструментальными средствами 
разработки, я ожидал какого-нибудь более продуктивного способа 
создавать современные крупномасштабные веб-приложения. Проект 
Dart казался как раз тем, что я искал. Я вырос на таких объектно-
ориентированных языках, как C++, Java и Ruby, которые применял 
при построении своих первых интерактивных веб-сайтов, а позже 
обогащенных веб-приложений с развитой клиентской частью. Я научился 
продуктивно работать с классами, объектами и модульным 
кодом. Я ценил интегрированные среды разработки (IDE) за встроенные 
в них средства анализа, рефакторинга и навигации, потому 
что они помогали мне писать большие и сложные приложения. 
Жизнь была прекрасна. Я искал новые направления приложения 
своих знаний, и мне повезло получить работу в команде, работавшей 
над браузером Chrome. Поначалу я осваивал современный браузер 
и с воодушевлением принялся изучать многочисленные новые возможности 
HTML5. Ныне сеть веб развивается так быстро и у нее 
появилось столько пользователей, что находиться в центре событий 
безумно интересно. Жизнь стала еще прекрасней.
И хотя итеративный процесс веб-разработки с его коротким циклом 
мне очень нравился, все же не хватало столь любимых мной 
структурных языков и полезных инструментов. Я хотел, чтобы 
программы для современных браузеров можно было писать в IDE, 
умеющих выполнять автозавершение кода, на языках с настоящими 
классами… перечислять можно долго.
Поэтому, услышав о Dart, я ухватился за представившуюся возможность. 
Писать для самой интересной платформы, да еще не от-

Предисловие

казываясь от навыков и инструментов, с которыми хорошо знаком 
и умеешь работать? Да кто же будет против!
И я был не единственным разработчиком, кто с радостью присоединился 
к проекту. Автор этой книги Крис Бакетт был одним из 
первых, кто принял Dart. Он завел свой блог Dartwatch в тот самый 
день, как Google анонсировала Dart, и этот блок по сей день живет 
и процветает. Крис участвовал в проекте с самого начала, поэтому 
естественно, что именно он написал одну из первых книг, призванных 
помочь другим разработчикам в изучении Dart.
Крис – потрясающий автор, потому что сумел написать книгу 
в условиях, когда язык и его библиотеки претерпевали постоянные 
изменения. Ему удалось осветить многочисленные аспекты проекта 
Dart. Особенно мне понравились примеры, в которых иллюстрируется 
не только функциональность базового языка, но и более сложные 
вопросы, касающиеся HTML5. Крис рассматривает одностраничные 
приложения и показывает, как с помощью Dart создаются современные 
приложения, работающие в браузере. Но и это не все – вы 
научитесь программировать на Dart даже серверные приложения!
После года напряженной работы, десятков тысяч сохранений 
в системе управления версиями, исправления тысяч ошибок и непрерывающейся 
обратной связи с сообществом мечта о структурном 
языке для веб-программирования стала реальностью. И хотя 
разработка Dart еще не завершена, сегодня мы – благодаря книге 
Криса – уже можем создавать замечательные приложения для современного 
Интернета. Ликуйте!
Сет Лэдд,
разработчик и пропагандист
Google

Вступление

В октябре 2011 года подтвердились слухи о том, что Google разработала 
новый язык, ориентированный на разработку сложных 
веб-приложений характерного для Google масштаба. Спустя месяц 
в сети был обнародован внутренний документ Google под названием «
Future of JavaScript» (Будущее JavaScript), из которого следовало, 
что в Google ведутся работы над языком, более подходящим 
для веб-разработки, чем JavaScript. Упоминалось даже предположительное 
название языка – Dash. Идея о создании нового языка 
родилась из-за медленного развития JavaScript, обусловленного 
отчасти тем, что в нем заинтересовано слишком много сторон и 
комитетов. Целью же было показать, каким мог бы стать JavaScript, 
если бы он был придуман сегодня. Основная задача формулировалась 
так: «сохранить динамическую природу JavaScript, но повысить 
производительность и обеспечить поддержку со стороны инструментальных 
средств при разработке крупных проектов». Кроме 
того, язык должен был допускать кросс-компиляцию на JavaScript. 
Апробационная техническая версия языка была представлена миру 
и получила название Dart.
Я как раз тогда закончил работу над крупным заказным справочным 
приложением, написанным на GWT и предназначенным 
для развертывания на устройствах с сенсорными экранами в среде, 
неблагоприятной для компьютеров. Технология Google Web Toolkit 
(GWT) была разработана Google для кросс-компиляции Java на 
JavaScript. GWT позволяет разработчику воспользоваться модульной 
структурой, типобезопасностью и инструментальной поддержкой 
Java при написании ориентированных на браузеры программ, 
не требующих подключения дополнительных модулей, таких как 
Flash или Silverlight. Потратив предшествующие два года на написание 
GWT-кода и координацию работы программистов из трех 
стран, я понимал, насколько ценны средства проверки кода в точках 
интеграции – то, чего так не хватает языку JavaScript. Меня также 
привлекала возможность использовать один и тот же код на сто-

Вступление

роне клиента и сервера – я видел, какие из этого можно извлечь 
преимущества.

Горя желанием узнать как можно больше о новом языке Dart, 

я прочитал всю имевшуюся документацию. На тот момент она состояла 
из исходного кода, нескольких примеров и спецификации 
языка. Мне казалось, что раз уж я потратил время на то, чтобы уложить 
эти знания у себя в голове, то было бы хорошо поделиться ими 
с публикой с помощью блога. Тогда-то я и завел блог Dartwatch, 
где опубликовал серию статей о том, как решаются типичные задачи 
в Dart: организация проекта, создание классов, взаимодействие 
с браузером. Одно цепляло за собой другое – и в конце концов издательство 
Manning обратилось ко мне с предложением написать 
книгу о Dart. Через год результат этой работы вышел из печати.

За минувший год у Dart было время созреть, а его разработчики 

внимательно прислушивались к отзывам и реагировали на них. Близилось 
время первой контрольной точки Dart, и в первоначальную 
спецификацию языка было внесено множество изменений по предложениям 
первых приверженцев, пытавшихся применить его для 
решения реальных задач. Сообщество этих приверженцев также занималось 
разработкой различных инструментов и библиотек, в том 
числе драйверов баз данных, библиотек двумерной и трехмерной 
графики и каркасов. Многие из них можно найти на сайте GitHub 
или Dartwatch.

Первая контрольная точка Dart (Milestone 1) – это крупное до-

стижение, дающее разработчикам возможность использовать базовый 
язык для создания впечатляющих библиотек и API, которые 
помогут превратить Dart в язык «все включено», каким его и видят 
идеологи в Google. С каждым днем Dart становится все лучше, 
а благодаря открытости проекта вы можете наблюдать за тем, что 
многочисленные разработчики помещают в репозиторий исходного 
кода (и даже принять в этом участие). Надеюсь, что эта книга поможет 
вам создать замечательные приложения на Dart.

Благодарности

Выяснилось, что написание книги – вовсе не такое простое дело, как 
мне казалось поначалу. Не будь поддержки со стороны всех участвующих 
в проекте сотрудников издательства Manning, вы вряд ли 
читали бы ее сегодня. Спасибо Майклу Стивенсу (Michael Stephens), 
который вообще предложил мне заняться этим делом, – проект оказался 
очень интересным. Многие сотрудники издательства трудились 
над редактированием, корректурой, подготовкой иллюстраций 
и выполнением кучи другой работы, связанной с производством 
книги, – спасибо всем вам.
Особо хочется отметить двух сотрудников Manning. Во-первых, 
спасибо Берту Бейтсу (Bert Bates) за то, что еще на ранних этапах 
работы он показал мне, как из сухого справочного материала сделать 
текст, который было бы приятно читать. Когда я начинал писать очередную 
главу, на периферии сознания неотступно присутствовала 
мантра: «Объясни Берту, почему ему нужно это знать…» Во-вторых, 
спасибо редактору Сюзанне Клайн (Susanna Kline), которая следила, 
чтобы каждая глава строго соответствовала своему названию, не позволяла 
мне расслабляться и заставляла выдерживать график.
Вокруг Dart сформировалось весьма активное сообщество разработчиков, 
которое пользуется для общения списком рассылки 
dartlang и системой Google+. Я хочу поблагодарить его участников 
Джона Эванса (John Evans) и Кэвина Мура (Kevin Moore) за техническое 
редактирование, а также Адама Сингера (Adam Singer), 
Мэтью  Батлера (Matthew Butler) и Ладислава Тона (Ladislav Thon), 
чьи предложения всегда были желанны.
Благодарю также всех членов сообщества, которые читали книгу 
и давали отзывы на разных этапах ее написания: Андрэ Робер-
же (Andre' Roberge), Кард Тасвелл (Carl Taswell), Чэд Дэвис (Chad 
Davis), Крэйг Ланкастер (Craig Lancaster), Дилан Скотт (Dylan 
Scott), Глен Стокол (Glenn Stokol), Йон Скит (Jon Skeet), Оливье 
Нугье (Olivier Nouguier), Рик Гофф (Rick Goff), Родни Боллинджер 
(Rodney Bollinger), Рокеш Дженки (Rokesh Jankie), Стив Притти 

Благодарности

(Steve Pretty), Терри Бэрч (Terry Birch) и Вильгельм Леман (Will-
helm Lehman).
Также спасибо всем, кто писал в форуме книги, указывая на неизбежные 
опечатки, и всем читателям предварительных вариантов – 
участникам программы Manning’s Early Access Program (MEAP).
Наконец, спасибо всем разработчикам Dart, в том числе Сету Лэд-
ду, который помогал мне и многим другим ранним приверженцам 
оставаться в курсе изменений по мере эволюции Dart от первоначальной 
версии к той, что мы имеем сегодня. Отдельная благодарность 
Сету за любезное согласие написать предисловие к этой книге.