This document provides an overview of the Dart programming language created by Google. It discusses Dart's structure as a new programming language with its own runtime environment and tools. Key features covered include Dart's static yet dynamic typing, use of classes and objects, namespaces, isolates for concurrency, and snapshots for faster startups. The document also provides code examples demonstrating Dart's syntax and how it handles concepts like generics differently than other languages like Java.

1. Google Dart
Eberhard Wolff
Architecture & Technology Manager
adesso AG
27.10.11

2. Dart: A Structure Web Programming Language
► New programming language
► New programming tools
► New open source project
► Currently in a preview
► …for feedback
27.10.11

3. The Team Behind Dart
► Lars Bak
> Beta language
> HotSpot Java VM
> V8 JavaScript VM in Google Chrome
> 18 software patents
► Gilad Bracha
> Computational Theologist and later Distinguished Engineer at
Sun
> Java Language Specification
> Java Virtual Machine Specification
► Both worked on Strongtalk (Smalltalk + static typing)
27.10.11 3

4. Why Dart?
► More and more web application with complex logic
► Will become a lot more: HTML5 on the rise
► So far: No really great languages designed to create large scale web applications
► Google: The competition is NOT JavaScript ... but fragmented mobile platforms
► GWT (Google Web Toolkit) already featured a Java to JavaScript compiler
► Dart is designed with simplicity and mass appeal in mind
27.10.11 4

5. Runtime Environment
► Dart has its own VM
► Open Source project
► Needed for some advanced features
► Dart can compile into JavaScript
► Runs on any browser
► Currently not very efficient
► i.e. about the same performance as first V8 releases
► Size of JavaScript code currently considerable
27.10.11 5

6. Hello World in Dart
main() {
print('Hello, Dart!');
}
► C like language
int fib(int n) {
if (n <= 1) return n;
return fib(n - 1) + fib(n - 2);
}
main() {
print('fib(20) = ${fib(20)}');
}
► Seemingly static typing
27.10.11

7. Objects and Classes
class Person {
String name;
Person(this.name);
}
main() {
Person p = new Person('Gilad');
print('Hi ${p.name} ');
}
► Easy to initialize fields
27.10.11 7

8. Objects and Classes
class Person {
String name;
String firstname;
Person(this.name);
Person.withFirstname(this.firstname,this.name);
}
main() {
Person p = new Person.withFirstname('Gilad','Bracha');
print('Hi ${p.firstname} ${p.name}');
}
► No method or constructor overloading
27.10.11 8

9. Namespaces
► Much like Java packages
► Might contain classes, interfaces, variables and functions
► Definition:
#library("http");
► Using:
#import("http.dart");
► Optional prefix:
#import("http.dart”,”http”);
27.10.11 9

10. Dart Library
27.10.11 10

11. Object Construction With Factories
interface Person class Adessi
factory PersonFactory { implements Person {
Person(name); Adessi(this.name);
final name; String name;
} }
class PersonFactory { class RealPerson
factory Person(name) { implements Person {
if (name == 'Wolff') { RealPerson(this.name);
return new Adessi(name); String name;
} }
return new RealPerson(name);
} main() {
} Person p
= new Person('Wolff');
print(p is Adessi);
p = new Person('Bracha');
► Very elegant approach to allow for other object print(p is Adessi);
creation algorithms }
27.10.11 11

12. More Complex Example
class Person {}
class Customer extends Person {
buy() {print("bought");}
}
main() {
Person p = new Customer();
p.buy();
}
27.10.11 12

13. More Complex Example
class Person {}
class Customer extends Person {
buy() {print("bought");}
}
main() {
Person p = new Customer();
p.buy();
}
► Code actually compiles and runs
► There are no type errors – only Static Warnings
► Types are considered annotations
► Type annotations never change the semantics of a program
27.10.11 13

14. On Types
► Type theory: A type defines a set of values and operations on them
> i.e.Java int: values: all integers from -2147483648 to 2147483647
> Operations on int: + - * etc
► Goal: Check types to find errors
> i.e. multiply a String by an int
> i.e. call a method that does not exist on an object
► Type checkers proof the partial correctness of programs
► i.e. at least types are correct
► Typing will only find basic errors
27.10.11 14

15. Dynamic Typing
► At runtime
► Advantage
> Simpler
> More flexible
> Can even implement methods on the fly – Meta programming
► Disadvantage
> Perceived as less secure
27.10.11 15

16. Static Typing
► Typing checked At compile time
► Advantage
> IDE support
> Documentation
> Perceived as safer
> …but problems should be found by Unit Tests, too!
► Disadvantage
> Overhead if no type inference
> Complex to get right in some case
> Complex (Java Generic FAQ by Anglika Langer is 297 pages !)
27.10.11 16

17. Generics in Java
► Does this code compile?
public class Customer extends Person {
…
}
public static void main(String[] args) {
List<Person> listOfPerson = new ArrayList<Person>();
List<Customer> listOfCustomer = new ArrayList<Customer>();
listOfCustomer=listOfPerson;
listOfPerson=listOfCustomer;
}
27.10.11 17

18. Generics in Java
► Does this code compile?
public class Customer extends Person {
…
}
public static void main(String[] args) {
List<Person> listOfPerson = new ArrayList<Person>();
List<Customer> listOfCustomer = new ArrayList<Customer>();
listOfCustomer=listOfPerson;
listOfPerson=listOfCustomer;
}
listOfPerson.add(new Person());
listOfCustomer.add(new Person());
Customer c = listOfCustomer.get(1);
Customer c = listOfPerson.get(1);
27.10.11 18

19. Generics and Static Typing in Java
► You can still mess with it
► Basically each type cast disables static typing
► i.e. it can introduce problems that otherwise would have been discovered by the
compiler
listOfPerson.add(new Person());
Object obj = listOfPerson;
listOfCustomer = (List<Customer>) obj;
Customer c = listOfCustomer.get(0);
27.10.11 19

20. Static vs. Dynamic Typing: My Take
► Errors found by a static type checker will also be found by unit tests
► The security of static typing is only perceived
► Real advantage: Documentation
► “I expect you to pass in a Customer!”
► “This gives you a Person!”
► Tool support
► Easier to come up with suggestions for content assist
► However, Dynamic languages tools are catching up
27.10.11 20

21. Generics in Dart
class Person {}
class Customer extends Person {
buy() {print("bought");}
}
main() {
List<Customer> listOfCustomer = new List<Customer>();
List<Person> listOfPerson = listOfCustomer;
listOfPerson.add(new Person());
Customer c = listOfCustomer[0];
c.buy();
}
27.10.11 21

22. Generics in Dart
class Person {}
class Customer extends Person {
buy() {print("bought");}
}
main() {
List<Customer> listOfCustomer = new List<Customer>();
List<Person> listOfPerson = listOfCustomer;
listOfPerson.add(new Person());
Customer c = listOfCustomer[0];
c.buy();
}
► Call to buy() won’t work
► Problem not found until the method is actually called
► Optional run time type checker would find the problem one line earlier
► Valid code: List<Customer> is a List<Person>
27.10.11 22

23. Generics in Dart
► Generics in Dart are considered covariant
► i.e. List<Customer> is List<Person>
► This is in fact logical incorrect (see last slide)
► But:
> Do you want to read 297 pages Generic FAQ?
> And: It is just a help to spot basic errors
27.10.11 23

24. Concurrency
public class MyCache {
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
public void add(int i, int j) {
map.put(i, j);
}
public int read(int i) {
return map.get(i);
}
}
► What is the problem?
27.10.11 24

25. Concurrency
public class MyCache {
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
public void add(int i, int j) {
map.put(i, j);
}
public int read(int i) {
return map.get(i);
}
}
► What is the problem?
► Code is not thread safe!
► Should use ConcurrentHashMap instead
27.10.11 25

26. Concurrency
► What is the real problem?
Threads
► Concurrency in object-oriented systems
► OO is based on concurrent access shared state
> Hard to get correct
> If you get it correct: performance bad
> Locks
> Synchronization
> Etc
Object with State
► Pretty low level concept
► This is why Carnegie Mellon dropped OO from the Computer Science curriculum!
► Can we do better?
27.10.11 26

27. Dart code is always single threaded!
27.10.11
27

28. Isolates
► Inspired by Actor model
► As present in Erlang
► As done in Scala with Actors and Akka Port
► Idea: State is hidden in Isolates Isolate
with State
► Isolates communicate with messages send to ports
► Each isolate only works on one message at a time
► No concurrency issues in an Isolate: Only one thread
► Still concurrent: Multiple isolates might be active at a time
27.10.11 28

29. Isolates
class Printer extends Isolate {
main() {
port.receive((message, replyTo) {
if (message == null) port.close();
else print(message);
});
}
}
main() {
new Printer().spawn().then((port) {
for (var message in ['Hello', 'from', 'other', 'isolate']) {
port.send(message);
}
port.send(null);
});
}
27.10.11 29

30. More Fun With Isolates
► Isolates might be mapped to Web Worker in JavaScript
► Nothing is shared
► Isolates will have their own heap on the Dart VM
> Messages must be serialized and deserialized
> Garbage Collection can happen per Isolate
> No more stop-the-world GC!
► Isolates might be used to introduce security concepts
> Enforce security rules on ports
> To replace Same Origin Policy
27.10.11 30

31. More Fun With Isolates
► Isolates require a light weight concurrency model
> OS Thread switches take too much time
> In Erlang 100.000 of Isolates equivalent are not uncommon
> No way to run that many threads
> Interesting issue for Dart VM
► Isolates for Remoting
> Can send messages to a port on a different host
> Semantics don’t change as serialization is done anyway
► Probably more high level concurrency models
► Specifications says that Isolates might run different versions of libraries
27.10.11 31

32. Even More Fun With Isolates
► In Erlang the concept is extended for high availability
> Links allow to listen to events of Isolates
> Supervisor can monitor other processes
> If an error occurs the isolate crashes and is restarted
> Hierarchies of supervisors can be created
> State is a problem here
> This makes high availability easy to develop
> Dart might come up with a similar solution
27.10.11 32

33. Snapshots
► VM can be snapshot
► Current heap etc
► Faster startup
> No need to create initial state, config, …
> Used in V8 already for standard JavaScript libraries
> How long does a JVM need to start up?
► Possible answer to mobile applications killed due to memory constraints
► Could be used to migrate isolates between machines
27.10.11 33

34. Dart Editor
► Editor for Dart applications
► Based on Eclipse
► Code in the Open Source Project
27.10.11 34

35. More Complex Example
► Swarm: A newsreader
► Completely written in Dart
> App code: 3210 LOC
> UI library code: 13200 LOC
> Animation yields 30 fps
> Runs on iPad and Chrome
27.10.11 35

36. Not Decided Yet…
► Currently a technology preview
► Some questions are open
> Reflection? Probably using Mirrors
> Changing classes on the fly? Probably not needed due to Isolates
> What about Chrome?
27.10.11 36

37. Links
► http://www.dartlang.org/
> Language Site
> Tutorials
> Language Spec
> Library Spec
> …
► http://dart.googlecode.com/
> Open Source project
> Including compiler, VM etc.
► http://code.google.com/p/jdart/
> Dart on the JVM
► http://it-republik.de/jaxenter/artikel/Google-Dart-4121.html
> German
► http://jonaswesterlund.se/dart.html
> Pre compiled Dart for Mac OS X
► http://www.infoq.com/articles/google-dart
27.10.11 37

38. Possible Applications for Dart
► Google App Engine
> Isolates are a nice fit for GAE’s restriction
> Snapshot will make it easy to move execution from
machine to machine
► Android
> As a replacement for Java
► Web Browser
> Compiling into JavaScript
27.10.11 38

39. Dart: Conclusion – Huge Potential
► Best shot at next generation web language so far
► Language designed to appeal to the masses
► Solves a real problem: Complex web applications
► Already possible to create cross platform web applications
► Google has a lot of resources and this solves a real problem for them
► Isolates and future concurrency models very interesting
> Client: Security
> Server: Modern concurrency
> …
27.10.11 39

40. 27.10.11
40