for Java Developers

About Me

• C# since 2005 till 2012

• Java since 2012

• JavaScript, Dart since 2013

• Working at Farata Systems

• Conduct trainings

2

What is Dart?

3

New programming language and platform created by for Web development

3

4

Blink…!WebKit…

Reader…

Code Search…Chrome Frame…

Dart is Truly OSS

• Public commits

• Public issue tracker

• Public code reviews

• Accept contributions

5

• Dart is ECMA standard (TC52)

• Also ECMA: JavaScript, C#, C++/CLI, JSON, ActionScript

6

What does it mean?

ECMA committee standardizes syntax,

semantics, core librariesWhy it is important?

Safe to develop own VMs and embed

in browsers

Team

• Lars Bak - HotSpot, V8, a Smalltalk VM, BETA

• Kasper Lund - HotSpot, V8, OOVM

• Gilad Bracha - Java Specification, Strongtalk, Newspeak

• Many other engineers

7

http://youtu.be/huawCRlo9H4 8

Timeline

9

Sep 1, 2011

Oct 10, 2011 Apr 9, 2014

1.0 ReleaseFirst commit

Announcement

Nov 14, 2013

1.3 Release

Dart at a glance

• Runs in VM

• Compiles to JavaScript

• Dynamically typed

• Object-oriented

• Single inheritance

• Single-threaded

• Familiar sytax

10

How is it better than JS?

• Faster

• Predictable (no hoisting, no type coercion, etc.)

• Rich standard libraries

• Structured apps

• Good tooling

• Packaging system

11

What's Your Benefit?

12

Q: Front-end Developer? A: Build reliable apps faster

Q: Back-end Developer? A: Probably just curiosity

Language Tour

13

Hello World

14

// Formal examplevoid main(List<String> args) { print('Hello from Dart!');}// Shorter versionmain() => print('Hello from Dart!');

• Explicit entry point

Built-in Types

15

int var i = 1;var hex = 0xABCD;

double var d = 1.2;var exp = 1.2e9;

String var s1 = 'single quotes';var s2 = "double quotes";

bool var b1 = false;var b2 = true;

Symbol var sym1 = #mySymbol;var sym2 = const Symbol('mySymbol');

List var list = ['item1', 'item2', 'item3'];

Map var map = {'key1': 'val1', 2: 'val2', []: 'val3'};

JSON is valid Dart Syntax

16

var map = { 'firstName' : 'John', 'lastName' : 'Doe', 'age' : 30, 'addresses' : [ { 'street': '' //... }, { 'street': '' //... } ] };

• List and Map literals make JSON a valid Dart syntax

Optional Types Example

• Best practice - explicit types for method signatures and class members, for local variables - var

main() { var a = 1; var b = 2; var c = divide(a, b); assert(c == 0.5); } !divide(a, b) { return a / b; }

void main() { int a = 1; int b = 2; double c = divide(a, b); assert(c == 0.5); } !double divide(int a, int b) { return a / b; }

17

Optional Types Rules

• All type annotations can be omitted

• Has no effect at runtime

• App without types has the same semantics

• Do not cause errors, only warnings

• You can always “compile” and run your program

18

Benefits of Type Annotations

• Act as documentation

• Advanced tools support (completion, code navigation, etc.)

• Error detection via type checker

• Can improve performance while compiling to JavaScript

19

Declaring Variables

20

• null is default value for all types

• Supports final and const

var str1 = ''; // type is dynamic (implicit)String str2 = ''; // type is StringObject str3 = ''; // type is Objectdynamic str4 = ''; // type is dynamic (explicit)

Functions

21

// Top-level functionsvoid log(String message) { print(message);}// Single expression functionsvoid log(String message) => print(message);// Nested functionsvoid main() { void log(String msg) => print(msg); log('done');}

Higher-order functions

22

// Accept function as parametervoid doSomething(Function callback) { //... callback();}doSomething(() => log('done'));// Return functionFunction getLogger() { return (String msg) => log(msg, level: 'INFO');}// Assign to a variablevar logger = getLogger();logger('done');// Define function-type aliasestypedef void Logger(String msg);Logger getLogger() { return (String msg) => log(msg, level: 'INFO');}

Optional Parameters

23

/// [level] parameter has default value void log(String msg, [Error error, String level = 'INFO']) { //...} log('Bad value'); log('Bad value', new ArgumentError()); log('Bad value', new ArgumentError(), ‘ERROR');

Positional parameters:

void log(String msg, {Error error, String level}) { //...} log('Bad value'); log('Bad value', level: 'ERROR');log('Bad value', level: 'ERROR', error: new ArgumentError());

Named parameters:

Classes

24

Class members

25

class WampService { // Instance member WebSocket socket; // Final member final String id; // Static member static int buffer_size = 0; // Const member static const String URL = ‘ws://localhost/ws’;}

• Declaratively defined classes and members

Getters & Setters

26

class WampService { WebSocket _socket; get socket => _socket != null ? _socket : _socket = new WebSocket(); set socket(WebSocket s) { if (_socket.readyState != WebSocket.OPEN) _socket = s; else throw new StateError(); }}

Constructors

27

class Person { String name; DateTime birthday; Person(String name, DateTime birthday) { this.name = name; this.birthday = birthday; }}

Automatic Assignment

28

class Person { String name; DateTime birthday; Person(this.name, this.birthday);}

Initializers

29

class Person { String name; DateTime birthday; Person(): name = '', birthday = new DateTime.now();}

Named constructors

30

class Collection { //... // Ordinary constructor Collection(List source) {} // Named constructor Collection.empty() {}}var c = new Collection.empty();

Factory constructors

31

// Publicly expose abstract classabstract class Service { void doSomething(); // Expose concrete implementation via factory constructor factory Service() => new _DefaultService();} // Internally provide concrete implementationclass _DefaultService implements Service { void doSomething() {}} // You can invoke factory constructors of abstract classesvar s = new Service();

• Indirect instantiation

Factory constructors

32

class Service { static final Map<String, Service> _cache = {}; String name; factory Service(String name) => _cache.putIfAbsent(name, () => new Service._(name)); Service._(this.name);}

• Caching pattern

Java: Builder pattern

33

public class User { private String firstName; // required private String lastName; // required private String phone; // optional private int age; // optional private User(UserBuilder builder) { this.firstName = builder.firstName; this.lastName = builder.lastName; this.age = builder.age; this.phone = builder.phone; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public int getAge() { return age; } public String getPhone() { return phone; } // TO BE CONTINUED...

// Static nested class public static class UserBuilder { private String firstName; private String lastName; private String phone; private int age;! public UserBuilder firstName(String firstName) { this.firstName = firstName; return this; } public UserBuilder lastName(String lastName) { this.lastName = lastName; return this; } public UserBuilder age(int age) { this.age = age; return this; } public UserBuilder phone(String phone) { this.phone = phone; return this; } public User build() { return new User(this); } }}

Dart: a kind of “Builder pattern”

34

class User { String firstName; String lastName; String phone; int age;

// Here "this" enables type checking. User({this.firstName, this.lastName, this.phone, this.age});}// Usagevar user = new User( firstName: 'John', lastName: 'Doe', phone: '+123456789', age: 30);

Cascade operator

35

// Equivalent declarationclass User { String firstName; String lastName; String phone; int age; User(this.firstName, this.lastName);}// Usagevar user = new User('John', 'Doe') ..age = 30 ..phone = '+123456789';

Automatic Fluent APIs

36

querySelector('h1') ..text = 'Welcome!' ..classes.add('caption') ..onClick.listen((_) => print('clicked'));

Abstract Classes

37

abstract class AuthService { void login(String user, String password) { /*...*/ } void register(String user, String email, String password);}class BasicAuthService extends AuthService { void register(String user, String email, String password) { /*...*/ }}

• abstract keyword only for class declaration

Inheritance

38

abstract class AuthService { AuthService(String token) { /*...*/ } void login(String user, String password) { /*...*/ } void register(String user, String email, String password);} class BasicAuthService extends AuthService { BasicAuthService(String token): super(token); @override void login(String user, String password) { _ensureUnique(user); super.login(user, password); } @override void register(String user, String email, String password) { /*...*/ } _ensureUnique(String user) { /*...*/ } }

Interfaces

• Each class implicitly defines an interface

39

abstract class AuthService { String get token => ''; final String URL = ''; AuthService(String token) { /*...*/ } void login(String user, String password) { /*...*/ } void register(String user, String email, String password);} class BasicAuthService implements AuthService { String get token => ''; final String URL = ''; @override void login(String user, String password) { /*...*/ } @override void register(String user, String email, String password) { /*...*/ } }

Mixins

40

abstract class Storage { void save() { /*...*/ } String toJson();}class Person extends Object with Storage { String name; String toJson() => '{ "name": "$name" }';}var p = new Person();p.save();

• Mixin class must: extend Object, declare no constructors, no calls to super

Generics

41

var dynamics = new List(); // new List<dynamic>();dynamics.add('string'); // always OKdynamics.add(42); // always OKString s = dynamics.first; // always OKString i = dynamics.last; // FAILS in checked mode

• You are not required to use them • dynamic is default

Covariance

42

class A {}class B extends A {} !List<A> listA = new List<B>();listA.add(new A()); // FAILS in checked modelistA.add(new B()); // always OKA b1 = listA.last; // always OKB b2 = listA.last; // always OK

• No wildcards or explicit bound constraints required

Contravariance

43

class A {}class B extends A {}void acceptsListOfB(List<B> list) => list.add(new B());void acceptsList(List list) => list.add(new B());// No way to hint we use it only contravariantly.acceptsListOfB(new List<A>());// OK static checking// FAILS in checked mode// OK in runtime// Workaround - loose the declarationacceptsList(new List<A>());// OK static checking// OK in checked mode// OK in runtime// However, silences type checking and permits invalid usageacceptsList(new List<int>());// OK static checking// OK in checked mode// FAILS in runtime

Libraries• Dart libraries is a more flexible equivalent to Java packages

44

// myapp.dartlibrary myapp;import 'dart:io';part 'services.dart';part 'models.dart';!// services.dartpart of myapp;!// models.dartpart of myapp;

// services.dartlibrary myapp.services; !// models.dartlibrary myapp.models;!// myapp.dartlibrary myapp;import 'services.dart';import 'models.dart';export 'services.dart' show IntegrationService;

Futures

45

new Future(() => print('Async job 1')) .then((_) => print('Async job 2')) .then((_) => print('Async job 3')) .catchError((err) => print(err));

Streams

46

Stream<List<int>> inputStream = new file.openRead();inputStream .transform(UTF8.decoder) .transform(new LineSplitter()) .listen((String line) => print(line));

VM

• No bytecode

• Dart is a native language for Dart VM

• Enables dev tools and server-side apps

• In future - embedded into browsers

47

Performance

• Dart VM in average 1.5-2 times faster than JS/V8

• dart2js is almost the same as JS/V8

• 10x faster startup using snapshots

48

Benchmarks

49

dart

js: v8

dart2js: v8

• More here: https://www.dartlang.org/performance/

Tools

50

Dart Editor

51

IntelliJ IDEA/WebStorm

52

Dartium

53

Pub

54

More Tools

• dart2js

• dartanalyzer

• dartfmt

• docgen

55

Resources

• https://www.dartlang.org

• Articles

• Benchmarks

• AngularDart

• DartlangTV YouTube channel

56

Thanks!

Contacts:

• twitter.com/antonmoiseev

• a@antonmoiseev.com

57