By Neil Green (@neilfeyn). (Please hold questions until the end)

by Neil Green (@neilfeyn)

(Please hold questions until the end)

Rules of this talk:

• Please be nice.• Please be respectful.• Please don’t throw things.• Please take no personal offense to anything I may

say, imply, or infer regarding programming languages.• Please forgive me if I am not 100% accurate or

complete in my slides (I err on the side of conciseness.)

To keep everyone calm and relaxed before and/or after stressful slides, periodically

photos of cute kittens will be shown.

Understanding My Perspective

Why only a crazy person

would attempt this talk• There is no way to do this topic justice in an hour.• Developers are fiercely opinionated about

languages, especially JavaScript.• This talk can also be cast as “Static vs Dynamic

Typing” or “Java vs [insert language]”• Regretably, this topic now also invites AngularJS +

TypeScript vs ReactJS + Flow debates.• It is incredibly difficult to not come across as biased

on this topic - but I will try!

Things I am not

• A language designer – I am a language user.• An academic – I work to get paid.• Flawless in my memory and understanding in

TypeScript, CoffeeScript, and ES6 (but I did a lot of preparation for this talk).• Totally familiar with your programming language

such that I can answer any comparison/contrast questions.• Able to teach you 3 programming languages in 60

minutes, much less demonstrate their full capabilities.

My Perspective on

Programming Languages

• Have written JavaScript since 1997• Have written CoffeeScript exclusively since 2011• Have never written TypeScript professionally• Coded Java on and off since 1999 (~5 years total)• Have gotten to use many of the new ES6s features• Dabbled in Ruby and Scala over the years• Learning Haskell and ClojureScript currently• I pick whatever Language the situation requires

For simplicity I am going to refer to JavaScript language versions prior to

ES6 as simply “JavaScript”

JavaScriptCoffeeScript Transpiles to TypeScriptTranspiles to

ES6

Extended by

Extended by

If Jeremy decides the feature is important,

can be extended by

Babel

Transpiles to

Overview of Languages and Transpilers

Crash Course in the Languages

Crash Course in ES6

ES6 History

• JavaScript developed by Brendan Eich in 1995• Netscape released in 1996 supporting JavaScript• Microsoft created JScript dialect in 1996• Ecma International standardized ECMA-262 to

settle disputes between browser vendors• ECMA-262 standardized ECMAScript• ECMA-262 had 5 editions, with a 6th scheduled for

mid 2015 (ES6)

JavaScript Keywords• break• case• catch• continue• debugger• default• delete• else

• finally• for• function• if• in• instanceof• new• return

• switch• this• throw• try• typeof• var• while• with

ES6 Keywords• break• case• class• catch• const• continue• debugger• default• delete• do• else• export

• extends• finally• for• function• if• import• in• instanceof• let• new• return• super

• switch• this• throw• try• typeof• var• void• while• with• yield

E56 Features• Arrow Functions• Classes• Enhanced object literals• Template strings• Destructuring• default + rest + spread• let + const• iterators + for..of• Generators• Unicode• Modules

• Module loaders• map + set + weakmap +

weakset• Proxies• Symbols• Subclassable built-ins• Promises• math + number + string + array

+ object APIs• Binary and Octal literals• Reflect API• Tail calls

https://github.com/lukehoban/es6features

Because lists of keywords and features are a poor way to compare languages, we are going to look at

the same simple class implementation written in each language.

User

- id:int- firstName:String- lastName:String

+ getId():int+ getFirstName():String+ setFirstName(String):void+ getLastName():String+ setLastName(String):void

user = new User(123, ‘John’, ‘Smith’)

class User { constructor(id, firstName, lastName) { this.id = id; this.firstName = firstName; this.lastName = lastName; } getId() { return this.id; } getFirstName() { return this.firstName; } setFirstName(firstName) { this.firstName = firstName; } getLastName() { return this.lastName; } setLastName(lastName) { this.lastName = lastName; }}

User



ES6

ES6 Bottom Line

• ES6 has various features supported in various browsers• If you want to use ES6 features in all browsers now

use Babel

Crash Course in TypeScript

TypeScript History

• Typescript was first made public in October 2012• Anders Hejlsberg, lead architect of C# and creator of

Delphi and Turbo Pascal, has worked on the development of TypeScript• Originated from the perceived short-comings of

JavaScript for the development of large-scale applications both at Microsoft and among their external customers.• As TypeScript is a superset of JavaScript, any existing

JavaScript programs are also valid TypeScript programs.

TypeScript Features

• Type annotations• Public/Private• Compile-time type

checking• Type inference• Interfaces

• Enums• Mixin• Generics• Optional properties• Tuple types

class User { private id: number; private firstName: string; private lastName: string;

constructor(id: number, firstName: string, lastName: string) { this.id = id; this.firstName = firstName; this.lastName = lastName; } getId() { return this.id; } getFirstName(): string { return this.firstName; } setFirstName(firstName: string) { this.firstName = firstName; } getLastName(): string { return this.lastName; } setLastName(lastName: string) : void { this.lastName = lastName; }}

User



TypeScript

TypeScript Bottom Line

• If you are used to Java and C#, you should feel at home in TypeScript.• If you hate looking at Type information, you should

not use TypeScript.• If believe in compile-time type checking, use

TypeScript.• If you have problems with Type-related bugs in

JavaScript, use TypeScript.• If you are not going to make use of Type

annotations, just use ES6.

Crash Course in CoffeeScript

CoffeeScript History

• Created by Jeremy Ashkenas, who also created Backbone.js and Underscore.js.• First version released December 24th, 2010• Goal was to create, “A language that takes out the

frustrating and overly verbose bits of JS, and provides a safer, briefer way to stick to the good parts.”

CoffeeScript Features• Everything is an Expression

(mostly)• Whitespace to delimit blocks of

code• Optional parens• Optional postfix• Classes, Inheritance, and Super• Operators and Aliases• Iterations• Splatting• Comprehensions• Arrow Functions

• Destructuring Assignments• Chained Comparisons• Block Strings• Prototype Shorthand• Parameters to Properties

Binding• Class/Static Functions• Existential Operator• Bound and Generator

Functions• Block Regular Expressions• Default parameters

class User constructor (@id, @firstName, @lastName) ->

getId: -> @id

getFirstName: -> @firstName

setFirstName: (@firstName) -> getLastName: -> @lastName

setLastName: (@lastName) ->

User



CoffeeScript

CoffeeScript Bottom Line

• If you want as little “noise” as possible when reading you programs, use CoffeeScript.• If you like Haskell and Ruby, you should like

CoffeeScript.• You are at Jeremy’s whim when it comes to ES6

language features (though you can use ES6 APIs)

Recap of Code Samples

class User { constructor(id, firstName, lastName) { this.id = id this.firstName = firstName this.lastName = lastName } getId() { return this.id } getFirstName() { return this.firstName } setFirstName(firstName) { this.firstName = firstName } getLastName() { return this.lastName } setLastName(lastName) { this.lastName = lastName }}

User



ES6

class User { private id: number; private firstName: string; private lastName: string;

constructor(id: number, firstName: string, lastName: string) { this.id = id; this.firstName = firstName; this.lastName = lastName; } getId() { return this.id; } getFirstName() : string { return this.firstName; } setFirstName(firstName: string) { this.firstName = firstName; } getLastName() : string { return this.lastName; } setLastName(lastName: string) : void { this.lastName = lastName; }}

User



TypeScript

class User constructor (@id, @firstName, @lastName) ->

getId: -> @id

getFirstName: -> @firstName

setFirstName: (@firstName) -> getLastName: -> @lastName

setLastName: (@lastName) ->

User



CoffeeScript

Key Selection Criteria

Language Features

TypeScript has many features for you to use

class Sphere implements Thing { public radius2: number;

constructor(public center: Vector, radius: number, public surface: Surface) { this.radius2 = radius * radius; } normal(pos: Vector): Vector { return Vector.norm(Vector.minus(pos, this.center)); } intersect(ray: Ray) { var eo = Vector.minus(this.center, ray.start); var v = Vector.dot(eo, ray.dir); var dist = 0; if (v >= 0) { var disc = this.radius2 - (Vector.dot(eo, eo) - v * v); if (disc >= 0) { dist = v - Math.sqrt(disc); } } if (dist === 0) { return null; } else { return { thing: this, ray: ray, dist: dist }; } }}

CoffeeScript has many features for you to use

launch() if ignition is on

volume = 10 if band isnt SpinalTap

letTheWildRumpusBegin() unless answer is no

if car.speed < limit then accelerate()

winner = yes if pick in [47, 92, 13]

print inspect "My name is #{@name}“

solipsism = true if mind? and not world?

speed = 0speed ?= 15

footprints = yeti ? "bear“

grade = (student) -> if student.excellentWork "A+" else if student.okayStuff if student.triedHard then "B" else "B-" else "C"

eldest = if 24 > 21 then "Liz" else "Ike"

ES6 has many features for you to use

function* anotherGenerator(i) { yield i + 1; yield i + 2; yield i + 3;}

function* generator(i){ yield i; yield* anotherGenerator(i); yield i + 10;}

var gen = generator(10);

console.log(gen.next().value); // 10console.log(gen.next().value); // 11console.log(gen.next().value); // 12console.log(gen.next().value); // 13console.log(gen.next().value); // 20

function letTest() { let x = 31; if (true) { let x = 71; // different variable console.log(x); // 71 } console.log(x); // 31}

Understandability

I am a happy coder

English

Ich bin ein glücklicher Coder

German

Ik ben een gelukkig coder

Dutch

Je suis un codeur heureux

Fench

Soy un codificador feliz

Spanish

나는행복 코더 입니다Korean

我是一个快乐编码器Chinese

The more familiar you are with the language, the easier it is to understand

I am a happy coder

Happy, a coder I am

Me happy with be coder

i ‘m hppy cdr

I I am am a a happy happy coder coder

John Smith writes Java code, and as a result feels the emotion of happiness.

I am, you see, someone who is in fact, indubitably, and unerringly, beyond a shadow of a doubt someone who, in

truth, does truly greatly enjoy – nay, is - indeed happy being a coder.

Once, when I was a boy, I dreamed of a life where I could be happy. Happy, that is, in not just anything. No, it would have to be

something that I enjoyed – something perhaps I could not live without. “What

could this thing be?” I asked myself. Coding. It was coding that filled my head

with overwhelming joy. Joy before which I had never known. To code is to know

happiness. To be happy is to code. I am a coder, and therefore, I am happy.

The more well written the language, the easier it is to understand

Bug Prevention

TypeScript compile-time type checking is thought to lead to fewer bugs, especially in larger code bases

class FizzBuzz { static fizz = 'Fizz'; static buzz = 'Buzz';

generate(input: number): string { var output = '';

if (input % 3 === 0) { output += FizzBuzz.fizz;

}

if (input % 5 === 0) { output += FizzBuzz.buzz; }

return output === '' ? input.toString() : output; }}

normalNumbersReturnOriginalNumber() { this.areIdentical('1', target.generate(1)); this.areIdentical('2', target.generate(2)); this.areIdentical('4', target.generate(4));}

numberDivisibleByThreeShouldReturnFizz() { this.areIdentical(FizzBuzz.fizz, target.generate(3)); this.areIdentical(FizzBuzz.fizz, target.generate(6)); this.areIdentical(FizzBuzz.fizz, target.generate(9));}

numbersDivisibleByFiveShouldReturnBuzz() { this.areIdentical(FizzBuzz.buzz, target.generate(5)); this.areIdentical(FizzBuzz.buzz, target.generate(10)); this.areIdentical(FizzBuzz.buzz, target.generate(20));}

numbersDivisibleByThreeAndFiveShouldReturnFizzBuzz() { this.areIdentical(FizzBuzz.fizz + FizzBuzz.buzz, target.generate(15)); this.areIdentical(FizzBuzz.fizz + FizzBuzz.buzz, target.generate(30)); this.areIdentical(FizzBuzz.fizz + FizzBuzz.buzz, target.generate(45));}

CoffeeScript, because of its brevity, is thought to reveal bugs more easily.

class FizzBuzz @fizz = 'Fizz' @buzz = 'Buzz'

generate: (input) -> output = ''

output += @fizz if input % 3 is 0 output += @buzz if input % 5 is 0 if output is '' then input.toString() else output

normalNumbersReturnOriginalNumber = -> @areIdentical '1', target.generate 1 @areIdentical '2', target.generate 2 @areIdentical '4', target.generate 4 numberDivisibleByThreeShouldReturnFizz = -> @areIdentical FizzBuzz.fizz, target.generate 3 @areIdentical FizzBuzz.fizz, target.generate 6 @areIdentical FizzBuzz.fizz, target.generate 9 numbersDivisibleByFiveShouldReturnBuzz = -> @areIdentical FizzBuzz.buzz, target.generate 5 @areIdentical FizzBuzz.buzz, target.generate 10 @areIdentical FizzBuzz.buzz, target.generate 20 numbersDivisibleByThreeAndFiveShouldReturnFizzBuzz = -> @areIdentical FizzBuzz.fizz + FizzBuzz.buzz, target.generate 15 @areIdentical FizzBuzz.fizz + FizzBuzz.buzz, target.generate 30 @areIdentical FizzBuzz.fizz + FizzBuzz.buzz, target.generate 45

Making a Decision

Picking Something based on Features

My Most Used Features oniPhone First Gen

1. Apps2. Taking Pictures3. Checking Email4. Browsing Internet5. Text Messaging6. Making phone calls

New Features iniPhone 6

• More Bigger• More Thinner• More Better Camera• More Faster Processor• More Sensors• More Better Keyboard• Apple Pay

My Most Used Features oniPhone 6

1. Apps2. Taking Pictures3. Checking Email4. Browsing Internet5. Text Messaging6. Making phone calls

Giving Context to Understandability

“Dad, there’s a weird van in front of my house”

“Officer, my daughter has a weird van in front of her house. She lives on 7890 Chesapeake Lane.”

“…Van is a 1996-year Plymouth Green Minivan with gray lower trim parked in front of 7890 Chesapeake

Lane.”

Properly PrioritizingBug Prevention

$1 Billion

$100 Million

x 1.48 = F-35

x 13 = Carrier

x 1 = Your Ass

My Advice

Use TypeScript if…

• You love Java/C# and hate JavaScript• You use Microsoft Visual Studio, or generally like

IDE refactoring support.• You find yourself doing a lot of instanceof/type of

guards in your JavaScript to prevent bugs• You know that a lot of your bugs could be caught by

Type checking• You have a large, divergently skilled team who don’t

have the opportunity to mesh/gel together on code conventions.

Use CoffeeScript if…

• You love Haskell/Ruby and hate JavaScript• You believe that brevity leads to fewer bugs than

verbosity.• You hate looking at “noise” in your code• You are going to take advantage of CoffeeScript

language features.• You trust that Jeremy will keep his language up-to-

date with ES6 features

Use ES6 if…

• You love JavaScript• You don’t want to use the Type checking in

TypeScript.• You don’t want to ever miss out on features

because they are not added to CoffeeScript.• You want to be a part of the largest development

community, rather than a subset.

Questions?(remember to be nice)

Thank you!@neilfeyn

By Neil Green (@neilfeyn). (Please hold questions until the end)

Documents

Transcript of By Neil Green (@neilfeyn). (Please hold questions until the end)