anything to go by, most people are actually concerned with figuring out how to do things in JavaScript rather than complain about it. Press any letter after “javascript_“ and most likely Google will suggest a call for help. The sheer amount of people struggling with basic programming problems or core features of the language is simply staggering. 3 Introduction | Premise | Challengers | TypeScript
than PHP … but that’s not saying much. Yet whatever you may think of the TIOBE index, the language leapt from the 21st place in 1999 to the ninth in 2004, and has stayed there since. A quote from the TIOBE site explains their method: The TIOBE Programming Community index is an indicator of the popularity of programming languages. The index is updated once a month. The ratings are based on the number of skilled engineers world-wide, courses and third party vendors. Popular search engines such as Google, Bing, Yahoo!, Wikipedia, Amazon, YouTube and Baidu are used to calculate the ratings. Observe that the TIOBE index is not about the best programming language or the language in which most lines of code have been written. JavaScript keeps company with industry titans such as C, Java, Objective-C, C++, C#, PHP , Visual Basic and Python. 4 Introduction | Premise | Challengers | TypeScript
Destroy all Software both teaches and jokes about the nonsensical coercion rules and primitive operator overloads in the language. A must-see for anyone even slightly interested about web development: https://www.destroyallsoftware.com/talks/wat 6 Introduction | Premise | Challengers | TypeScript
like it is: “[…] we’re stuck with this crap for now… and despite all this stuff, we make amazing things. It’s way harder than it should be though, because in the back of our heads –at least in the back of my head, there’s this little voice that’s constantly whispering ‘bullshit… buuullshit’” 7 Introduction | Premise | Challengers | TypeScript
us are just baffled by it. function sorter(a,b) { if(a < b) return -1; if(a > b) return 1; return 0; } [10, '9', 8, 'seven', 6, 'all my fives', 4, '3', 2, '!!!11one', 0].sort(sorter) // [2, 8, "!!!11one", 0, "3", "9", 10, "all my fives", "seven", 4, 6] Opera 12 // ["all my fives", 0, "!!!11one", "seven", 2, "3", 4, 6, 8, "9", 10] Chrome // [8, "9", 10, "seven", 6, "all my fives", 2, "3", 4, "!!!11one", 0] FF // [2, "3", 8, "9", 10, "seven", 6, "all my fives", 4, "!!!11one", 0] IE JavaScript Guru Challenge: figure out each engine’s underlying implementation of sort() by looking at these results.
us are just baffled by it. function sortFuncAsc(a,b) { return a-b; } var points = [40,100,1,5,25,10]; points.sort(sortFuncAsc); // [1, 5, 10, 25, 40, 100] var points = ["apple", "banana", "pear", "zebra", "peach", "35", "", 53]; points.sort(sortFuncAsc); // ["pear", "banana", "zebra", "peach", "35", "", "apple", 53] Mixed type bags to be sorted is a fishy concept by itself, but why does JavaScript feel the need to keep chugging along? Why doesn’t this throw an exception? What could we possibly gain as developers by making these allowances?
a language with more than its share of bad parts. It went from non-existence to global adoption in an alarmingly short period of time. It never had an interval in the lab when it could be tried out and polished. It went straight into Netscape Navigator 2 just as it was, and it was very rough. When Java™ applets failed, JavaScript became the “Language of the Web” by default. JavaScript’s popularity is almost completely independent of its qualities as a programming language. […] The best nature of JavaScript is so effectively hidden that for many years the prevailing opinion of JavaScript was that it was an unsightly, incompetent toy. […] There was no careful review of the language or its problem domain. There was no review of its suitability or the soundness of its design. It was slapped together at Netscape, and then copied elsewhere. Given the process that created JavaScript and made it a de facto standard, we deserve something far worse. Javascript is a language of many contrasts. It contains many errors and sharp edges, so you might wonder, “Why should I use JavaScript?” There are two answers. The first is that you don’t have a choice. 10 Introduction | Premise | Challengers | TypeScript
typing in an age of static typing (weak or strong) resurgence due to improved language expressiveness to declare interfaces, contracts, constraints and concepts. Tooling, symbol navigation, static analysis and profiling are fields heavily tied to the ability to reason about types before runtime. 12 Introduction | Premise | Challengers | TypeScript
typing in an age of static typing (weak or strong) resurgence due to improved language expressiveness to declare interfaces, contracts, constraints and concepts. Tooling, symbol navigation, static analysis and profiling are fields heavily tied to the ability to reason about types before runtime. • Every object is an associative array. Keys are always strings. Performance suffers at the expense of allowing a limited form of reflection and, most importantly, duck typing. JIT-ing may work around this, but only insofar as it can reason it won’t have any side-effects. And if you’re hinting the JITter, you may as well simply statically type. 13 Introduction | Premise | Challengers | TypeScript
typing in an age of static typing (weak or strong) resurgence due to improved language expressiveness to declare interfaces, contracts, constraints and concepts. Tooling, symbol navigation, static analysis and profiling are fields heavily tied to the ability to reason about types before runtime. • Every object is an associative array. Keys are always strings. Performance suffers at the expense of allowing a limited form of reflection and, most importantly, duck typing. JIT-ing may work around this, but only insofar as it can reason it won’t have any side-effects. And if you’re hinting the JITter, you may as well simply statically type. • Numerics are floats. Always. Quoting the Standard: 4.3.19 Number value primitive value corresponding to a double-precision 64-bit binary format IEEE 754 value NOTE A Number value is a member of the Number type and is a direct representation of a number. 14 Introduction | Premise | Challengers | TypeScript
typing in an age of static typing (weak or strong) resurgence due to improved language expressiveness to declare interfaces, contracts, constraints and concepts. Tooling, symbol navigation, static analysis and profiling are fields heavily tied to the ability to reason about types before runtime. • Every object is an associative array. Keys are always strings. Performance suffers at the expense of allowing a limited form of reflection and, most importantly, duck typing. JIT-ing may work around this, but only insofar as it can reason it won’t have any side-effects. And if you’re hinting the JITter, you may as well simply statically type. • Numerics are floats. Always. Quoting the Standard: 4.3.19 Number value primitive value corresponding to a double-precision 64-bit binary format IEEE 754 value NOTE A Number value is a member of the Number type and is a direct representation of a number. • While prototype-based OOP is not inherently worse than class-based, __proto__ traversal is slow where non- virtuals aren’t. The “this” pointer’s context could be just about anything, no clear guidelines apply. 15 Introduction | Premise | Challengers | TypeScript
Electric Boogaloo • Here’s some words you won’t find in the ECMAScript Standard: “garbage”, “destructor”, “finalizer”, “deterministic”, “cleanup”, “free” (in the allocation sense), “allocation”, “memory” (except once, when talking about RegExp pattern evaluation). Huh. 16 Introduction | Premise | Challengers | TypeScript
Electric Boogaloo • Here’s some words you won’t find in the ECMAScript Standard: “garbage”, “destructor”, “finalizer”, “deterministic”, “cleanup”, “free” (in the allocation sense), “allocation”, “memory” (except once, when talking about RegExp pattern evaluation). Huh. • If the word “memory” is not there, “memory model” is also a no-show. It is no surprise then that “thread” is never mentioned. Not only is ECMAScript incapable of reasoning about synchronization primitives, atomics, volatiles or memory barriers: whether the implementation is single-threaded or multi-threaded is undefined. 17 Introduction | Premise | Challengers | TypeScript
Electric Boogaloo • Here’s some words you won’t find in the ECMAScript Standard: “garbage”, “destructor”, “finalizer”, “deterministic”, “cleanup”, “free” (in the allocation sense), “allocation”, “memory” (except once, when talking about RegExp pattern evaluation). Huh. • If the word “memory” is not there, “memory model” is also a no-show. It is no surprise then that “thread” is never mentioned. Not only is ECMAScript incapable of reasoning about synchronization primitives, atomics, volatiles or memory barriers: whether the implementation is single-threaded or multi-threaded is undefined. • No common or Standard Library. ECMAScript implementations (JavaScript, ActionScript, Node.js, etc.) have no common ground when it comes to simple matters such as Date/Time facilities, Unicode conversions, I/O, Math and Random. CommonJS is an active project that aims to deal with this precise matter. 18 Introduction | Premise | Challengers | TypeScript
Electric Boogaloo • Here’s some words you won’t find in the ECMAScript Standard: “garbage”, “destructor”, “finalizer”, “deterministic”, “cleanup”, “free” (in the allocation sense), “allocation”, “memory” (except once, when talking about RegExp pattern evaluation). Huh. • If the word “memory” is not there, “memory model” is also a no-show. It is no surprise then that “thread” is never mentioned. Not only is ECMAScript incapable of reasoning about synchronization primitives, atomics, volatiles or memory barriers: whether the implementation is single-threaded or multi-threaded is undefined. • No common or Standard Library. ECMAScript implementations (JavaScript, ActionScript, Node.js, etc.) have no common ground when it comes to simple matters such as Date/Time facilities, Unicode conversions, I/O, Math and Random. CommonJS is an active project that aims to deal with this precise matter. • No “byte” primitive. No elegant way to handle transport, protocols, streams, endianness, compression, hashing, obfuscation nor cryptography. UTF-8 characters and floating point numbers make for poor replacements. 19 Introduction | Premise | Challengers | TypeScript
Boogaloo Harder • Implementations are largely Garbage Collected, as the language omits proper out-of-the-box constructs to handle object lifetime. While GC is a mature and proven technique, low-power devices and mobile computing greatly benefit from deterministic destruction. Coupled with the lack of concurrency guarantees, all of ECMAScript seems counter to current trends in computing. 20 Introduction | Premise | Challengers | TypeScript
Boogaloo Harder • Implementations are largely Garbage Collected, as the language omits proper out-of-the-box constructs to handle object lifetime. While GC is a mature and proven technique, low-power devices and mobile computing greatly benefit from deterministic destruction. Coupled with the lack of concurrency guarantees, all of ECMAScript seems counter to current trends in computing. • The DOM facility is unusable, forever wrapped over by a more competent framework such as jQuery. 21 Introduction | Premise | Challengers | TypeScript
Boogaloo Harder • Implementations are largely Garbage Collected, as the language omits proper out-of-the-box constructs to handle object lifetime. While GC is a mature and proven technique, low-power devices and mobile computing greatly benefit from deterministic destruction. Coupled with the lack of concurrency guarantees, all of ECMAScript seems counter to current trends in computing. • The DOM facility is unusable, forever wrapped over by a more competent framework such as jQuery. • No native support for Futures and Promises, in a language that experienced a surge in popularity precisely by allowing advanced UI manipulation in a medium that desperately needed it. 22 Introduction | Premise | Challengers | TypeScript
Boogaloo Harder • Implementations are largely Garbage Collected, as the language omits proper out-of-the-box constructs to handle object lifetime. While GC is a mature and proven technique, low-power devices and mobile computing greatly benefit from deterministic destruction. Coupled with the lack of concurrency guarantees, all of ECMAScript seems counter to current trends in computing. • The DOM facility is unusable, forever wrapped over by a more competent framework such as jQuery. • No native support for Futures and Promises, in a language that experienced a surge in popularity precisely by allowing advanced UI manipulation in a medium that desperately needed it. • It borrows C’s syntax -a statically typed, compiled language closer to a high-level assembler than what we understand today for a programming language- for a dynamically typed, interpreted language. Did we really need switch case fall-through? 23 Introduction | Premise | Challengers | TypeScript
remember to “use strict”? • Do you know when to use the strict and coercing forms of the comparison operator? • Dynamic content? How do you programmatically build strings while minimizing temporaries? • Do you understand the scope hoisting rules? What’s ‘var’ for? How function names are tied to the global namespace as opposed to function objects? How about local scope of variables? What’s the ‘let’ keyword for? • Can you tell the “type” of an object? Even if it comes from a different window? Have you stopped asking for the type of objects and simply respect their duck-ness? • Do you ‘get’ prototypes? Why is __proto__ different from prototype? • Can you replicate the visibility patters for public, privileged (protected) and private without looking it up in Crockford’s homepage? • Do you understand the difference between string, Boolean and Number primitives and objects? • Do you know when to access nested variables by the member access operator and when to use the key indexer notation? What about non-string keys? • What does the ‘new’ keyword actually do? Why are there so many ways to build new objects? Must I use all? 41 Introduction | Premise | Challengers | TypeScript
• Iterators, do you even use them? What about generators? • Do you ‘get’ code using generator expressions and array comprehension? • { do you { still write unnecessary } brackets in your event handlers } or use expression closures? • Did you know your JSON2 library pretty much delegates the task to the browser as JavaScript now has native JSON support? • Do you use Object’s new facilities? Do you freeze properties to ensure immutability semantics in your functional code? Do you prevent misuse by inhibiting extension or sealing them? • Speaking of that, do you use actual properties? Getters and setters? • What about their descriptors? Do you know how to set and query these settings? • Proxies. I bet you never heard of these. Do you regularly encounter challenges where they are most welcome? • Can you more or less re-implement DOM related methods of jQuery using naught but the native window and document objects? • What about the AJAX calls? Or the promise/future utilities? What about the algorithm facilities of jQuery or Underscore.js? 42 Introduction | Premise | Challengers | TypeScript
truly important one: are you expecting with bated breath some feature from ECMAScript Harmony that is not class? 43 Introduction | Premise | Challengers | TypeScript
things are just toys in Mozilla’s backyard. It’s not about IE being retarded either, almost nothing works in Chrome/Safari. Some things do but as experimental “--harmony” switches. Check http://kangax.github.io/es5-compat-table/es6/ and weep. Then check the ES5 compatibility table and slowly realize what little of the things Mozilla implemented during the ‘00s was actually formalized into the current Standard. 46 Introduction | Premise | Challengers | TypeScript
is looking decent. I even got the urge to try it out while researching for these slides. BTW, did you notice this in Mozilla’s MDN site: *JavaScript is a trademark or registered trademark of Oracle in the U.S. and other countries. Oracle up-Sunning Sun, gentlemen. 58 Introduction | Premise | Challengers | TypeScript
media gaming. Currently at 0.9.72. Provided under the MIT license. Compiles to JavaScript. Can hint for the Closure compiler. Performs more aggressive in-lining of methods. Static Typing, Class-based OOP , Interfaces, Mix-ins, Generators, Templates, Imports (Python/Node.js like) 66 Introduction | Premise | Challengers | TypeScript
code sample. /*** * An example to use class templates */ class Queue.<T> { var _buf = new Array.<T>; function constructor() { } function enqueue(value : T) : void { this._buf.push(value); } function dequeue() : T { if (this.isEmpty()) { throw new Error("empty queue"); } return this._buf.shift(); } function isEmpty() : boolean { return this._buf.length == 0; } } class _Main { static function main(args : string[]) : void { var queue = new Queue.<string>; queue.enqueue("foo"); queue.enqueue("bar"); log queue.dequeue(); log queue.dequeue(); } } Un-compiled JSX source implementing a type-safe generic queue.
Currently at v20140110. Provided under the Apache license 2.0. Compiles JavaScript into better JavaScript machine-wise. Leverages specific hint annotations interspersed in the code as traditional comments. Provides warnings against “unsafe” or problematic usages of JS. Being JavaScript, roughly same feature set as ECMAScript 3. Upping the level of optimizations applied progressively restrict some corner cases. 71 Introduction | Premise | Challengers | TypeScript
a%15?a%3?a%5?a:"Buzz":"Fizz":"FizzBuzz"}); Compiled version, using ‘advanced’ compilation. Minification aside, note the rewrite deduced by control flow analysis, constant folding and tail call optimization.
Currently at 2.5.1. Provided under the Apache license 2.0. ‘Google Web Toolkit’ or ‘gwit’. Trans-compiles Java to JavaScript. Comes with JS implementations of commonly used Java classes from the library packages. (such as java.lang, java.util) Being Java, it features static typing, class-based OOP , generic programming through type erasure, checked exceptions, interfaces, automatic memory management, etc. 76 Introduction | Premise | Challengers | TypeScript
the GPL v2 license (library: MIT) A successor to ActionScript 2.0 (also an ECMAScript implementation). Can compile bytecode for different virtual machines, such as Flash, and trans-compile to other targets such as AS3 or JavaScript. Statically typed, class-based OOP , interfaces, functors, anonymous types, and a form of generic programming based on type erasure and constraints. 79 Introduction | Premise | Challengers | TypeScript
code sample. public static function memoize(func:Dynamic , hash_size:Int = 100) : Dynamic { var arg_hash = new Hash<Dynamic>(); var f = function(args:Array<Dynamic>){ var arg_string = args.join('|'); if (arg_hash.exists(arg_string)) return arg_hash.get(arg_string); else{ var ret = Reflect.callMethod({},func,args); if(Lambda.count(arg_hash) < hash_size) arg_hash.set(arg_string, ret); return ret; } } f = Reflect.makeVarArgs(f); return f; } A memoizer, a function that caches the result in case it’s called with the same argument(s).
Provided under the MIT license. Compiles to a subset of JavaScript that is highly optimizable by AOT (ahead of time) compilers. Meant for performance-critical blocks of code. Static Typing, block scoped, limited to primitives and an “any” type for inter-op, structs, unions, pointers, heap and stack arrays, manual memory management, implements “memory” by using JavaScript’s Typed Arrays singletons (works in all major browsers). Member scoping results in addressable offsets, no indirection, no GC activity/pressure. 84 Introduction | Premise | Challengers | TypeScript
code sample. struct Node { Node *next; int value; }; let Node *head = new Node, *tail = head; function Node *add(int value) { let Node *next = new Node; next->value = value; tail->next = next; tail = next; return next; } trace(add(1)); trace(add(2)); trace(add(3)); traceList(head->next); function void traceList(Node *p) { while (p) { trace("Node at address: " + p + ", has value: " + p- >value); p = p->next; } } A space efficient linked list using pointers and a struct, noticeably smaller than instancing objects. Far easier to reclaim its memory than for a GC to evaluate inter-dependencies. Faster to access nodes with less indirection, potentially allocated in a more contiguous sense RAM-wise.
no GC pauses of its own. Unviable for large-scale application development. Could be leveraged as an intermediate language. 87 Introduction | Premise | Challengers | TypeScript
Provided under the MIT license. A very strict subset of JavaScript that is highly optimizable by AOT (ahead of time) compilers. All major browsers currently detect asm.js code and optimize accordingly. Did not start truly as a language, nor a compilation target language, but the formalization of a pattern that allows aggressive optimization strategies, independently discovered by Emscripten and Mandreel. Other languages we will discuss here target asm.js rather than JavaScript proper, or at least are considering the possibility. 89 Introduction | Premise | Challengers | TypeScript
years of computer science away. Is meant as an intermediate language. The Right Answer for the “JavaScript alternative” question may depend in the future on how asm.js is leveraged, if we still compile to JS. 91 Introduction | Premise | Challengers | TypeScript
community. Provided under the MIT license. An LLVM trans-compiler that targets asm.js. Any language that compiles to LLVM can be used to write complex JavaScript applications. Primary languages fostered at LLVM are C, C++ and Objective-C. 93 Introduction | Premise | Challengers | TypeScript
mostly need to perform DOM updates and AJAX calls, our code would be a terrible mess of emscripten_run_script() evaluating pieces of JS everywhere. Much in the same way we could code C++ and target the .NET framework with C++/CX, it’s a good option to deal with space- & time-expensive code that needs to run on the client side rather than the server. 94 Introduction | Premise | Challengers | TypeScript
Currently at version 32.0. Provided under the new BSD license. A clever way to run a “safe” subset of x86 and ARM instructions in a sandbox, as a mechanism to safely run native code from within a web browser. A companion project, PNaCL (P for Portable), allows architecture-independent deployment, allowing each client to pre-compile to suit their needs. (not unlike MSIL on mono/.NET) Supports C/C++, excluding parts of the Standard Library that deal with things outside the sandbox. 96 Introduction | Premise | Challengers | TypeScript
ActiveX and it never worked outside of IE (if it worked at all). Mozilla’s Jay Sullivan says: "These native apps are just little black boxes in a webpage. [...] We really believe in HTML, and this is where we want to focus.“ Forget about widespread browser adoption. 97 Introduction | Premise | Challengers | TypeScript
Currently at version 1.0.0.10. Provided under the new BSD license. Dart programs can be run in the Dart VM, or trans-compiled to JavaScript. During August 2013 Google reports performance of the generated JS is within 78% of hand-written JS. Optionally typed, class-based OOP , single inheritance, abstract classes, interfaces, reified generics. 100 Introduction | Premise | Challengers | TypeScript
“I guarantee you that Apple and Microsoft (and Opera and Mozilla, but the first two are enough) will never embed the Dart VM.” Microsoft and Apple have stated similar remarks, denoting on the harmfulness of adding a new web facing language. 102 Introduction | Premise | Challengers | TypeScript
that Jeremy. Currently at version 1.6.3. Provided under the MIT license. Trans-compiles to JavaScript one-to-one; no extra interpretation required at runtime. Ruby/Haskell-like, popular enough to be built-in into Ruby on Rails, ranks low in the TIOBE index (#170) but ranks high in GitHub / StackOverflow. Can generate ‘source maps’ to map JS statements with their CS counterpart, aiding in debugging. 106 Introduction | Premise | Challengers | TypeScript
code sample. class Animal constructor: (@name) -> move: (meters) -> alert @name + " moved #{meters}m." class Snake extends Animal move: -> alert "Slithering..." super 5 class Horse extends Animal move: -> alert "Galloping..." super 45 sam = new Snake "Sammy the Python" tom = new Horse "Tommy the Palomino" sam.move() tom.move() The classical, terrible OOP example that makes every aspiring programmer prefer is-a relationships over has-a and uses-a.
migrated all JS logic to CS; GitHub is asking its developers to write all new JS as CS. If you have a problem with significant whitespace, you’re going to have a problem with well-written CS. If you like type safety, at least compile time checking, you’re out of luck. But wait, there’s another contender… 110 Introduction | Premise | Challengers | TypeScript
Mozilla’s “JavaScript” implementation would be version 2.0. Fixes a surprising amount of gaps in the current version of the Standard when extrapolating current trends in web development. Language improvements: ‘let’ and ‘const’ keywords, destructuring assignment, for…of, iterators, generators, rest and default parameters, spread operator, arrow functions, binary/octal literals. Library improvements: map, set, WeakMap, Proxy, new number, string and Math methods, 113 Introduction | Premise | Challengers | TypeScript
aimed for a December 2013 ratification of the Standard. That very same page now says December 2014. Some controversy and open discussions remain on non-trivial features. Which brings us to: 114 Introduction | Premise | Challengers | TypeScript
are no conflicts or ambiguities. (e.g. allowing one to write functions without specifying the signatures of its return type). This is natural to JS programmers. 124 Introduction | Premise | Challengers | TypeScript
typing system, much like ‘object’ in C#. Like in C#, it actually is a type that can be reasoned about. 125 Introduction | Premise | Challengers | TypeScript
typing system, much like ‘object’ in C#. Like in C#, it actually is a type that can be reasoned about. • Ambient declarations allow one to declare variables in scope that TypeScript currently can’t see, such as the DOM’s “document”. 126 Introduction | Premise | Challengers | TypeScript
typing system, much like ‘object’ in C#. Like in C#, it actually is a type that can be reasoned about. • Ambient declarations allow one to declare variables in scope that TypeScript currently can’t see, such as the DOM’s “document”. • Functions are first class citizens and can also be typed, allowing for precise callback, delegate and command processor semantics: 127 Introduction | Premise | Challengers | TypeScript function vote(candidate: string, callback: (result: string) => any) { … } var MakePoint: () => { x: number; y: number; };
the ‘class’ keyword. • Public and private visibility; used by TypeScript during its compile phase, not strictly enforced by the translated JS. 132 Introduction | Premise | Challengers | TypeScript
the ‘class’ keyword. • Public and private visibility; used by TypeScript during its compile phase, not strictly enforced by the translated JS. • Constructors can declare fields inline, for a more concise syntax: (BTW, expect this feature in C# soon) 133 Introduction | Premise | Challengers | TypeScript class BankAccount { constructor(public balance: number) { } deposit(credit: number) { this.balance += credit; return this.balance; } }
overloads for string literals can be declared; similar to a form of meta-programming with constant values common in C++: A run-time checked version is also possible, as the last example suggests. 135 Introduction | Premise | Challengers | TypeScript interface Document { createElement(tagName: "div"): HTMLDivElement; createElement(tagName: "span"): HTMLSpanElement; createElement(tagName: "canvas"): HTMLCanvasElement; createElement(tagName: string): HTMLElement; }
grammar: As expected, the compiler can often deduce the generic types due to co- or contra-variance (depending on context). 136 Introduction | Premise | Challengers | TypeScript interface Array<T> { reverse(): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; }
grammar: As expected, the compiler can often deduce the generic types due to co- or contra-variance (depending on context). • Support for Modules, allowing code reuse, library organization and hiding implementation details. 137 Introduction | Premise | Challengers | TypeScript interface Array<T> { reverse(): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; }
denote base-is relationships: • extends also works for interfaces/classes: 139 Introduction | Premise | Challengers | TypeScript interface G<T extends U, U extends Array<V>, V extends Function> { } interface A { a: string; } interface B extends A { b: string; } interface C extends B { c: string; }
denote base-is relationships: • extends also works for interfaces/classes: • Compile-time typeof(), has no impact in run-time, allows to check for structural subtyping (according to the spec, a named type and “something that looks like it” are indistinguishable). 140 Introduction | Premise | Challengers | TypeScript interface G<T extends U, U extends Array<V>, V extends Function> { } interface A { a: string; } interface B extends A { b: string; } interface C extends B { c: string; }
C#. • Lambda notation using => is similar to C# and aligned with ES6. • A sensible table of type requirements for logical, arithmetic, binary and conditional operators. 143 Introduction | Premise | Challengers | TypeScript
C#. • Lambda notation using => is similar to C# and aligned with ES6. • A sensible table of type requirements for logical, arithmetic, binary and conditional operators. • Interface implementation is a run-time check of contract matching. 144 Introduction | Premise | Challengers | TypeScript
explicitly implement an interface using the “implements” keyword, gaining compile-time checks. • “static” supplies non-instance properties for classes. • Can auto-initialize properties directly in the declaration. 147 Introduction | Premise | Challengers | TypeScript
explicitly implement an interface using the “implements” keyword, gaining compile-time checks. • “static” supplies non-instance properties for classes. • Can auto-initialize properties directly in the declaration. • Can override members, and use “super” to access the hidden token. 148 Introduction | Premise | Challengers | TypeScript
DefinitelyTyped @ https://github.com/borisyankov/DefinitelyTyped A large repository of modules with interfaces and ambient declarations explaining all the famous libraries you depend on, allowing compile-time checking on how your code uses them. They’re even documented.
the ‘any’ type from interfering with some of the language’s features. Overload resolution rules changed slightly. Lambdas immediately called on now require enclosing parentheses. etc. 156 Introduction | Premise | Challengers | TypeScript
includes native support), facilitating compile-on-build, Intellisense, warning/error parsing, etc. • R# 8.1 (a free minor update to 8) includes TypeScript support for typing assistance, code completion and code rearrangement. • The TypeScript compiler (“tsc”) is a Node.JS application installed via the ‘npm’ packet manager. • The NuGet package Bundle Transformer at CodePlex provides enhanced MVC-like bundling of resources (compilation/translation, minification, concatenation) for JS, TS, CSS, LESS, SASS, etc. • Someone forked TS to target Google’s Closure Compiler, taking leverage of all the reasoning and inference performed by the TS compiler to annotate the target JS. 162 Introduction | Premise | Challengers | TypeScript
warashi
mana_takada
masaruhr
euglena1215
yuukiw00w
munetoshi
chobishiba
nealle
falcon8823
77web
kesoji
saitoryc
chriscoyier
rmw
jlugia
lynnandtonic
sugarenia
cassininazir
maltzj
smashingmag
akosma
philnash
iamctodd
csswizardry
![73 Introduction | Premise | Challengers | TypeScript for(var b=100,c=[];b--;)c.push(b+1);c.reverse().map(function(a){return](https://files.speakerdeck.com/presentations/f12437d0616d0131112c5e43feed75e2/slide_72.jpg){kind=link}
