Title: JavaScript 2.0: Evolving a Language for Evolving Systems
1JavaScript 2.0 Evolving a Language for Evolving
Systems
2Outline
- Background
- Motivation
- Construct the JavaScript 2.0 language
- Process
- Conclusion
3JavaScript History
- Web page scripting language invented in 1996 by
Brendan Eich at Netscape - Used in over 25 of web pages
- More than an order of magnitude more widely used
than all other web client languages combined
4Terminology
- LiveScript
- JavaScript
- Jscript
- ECMAScript
- All the same language
- No relation to Java
5JavaScript Evolution
- JavaScript 1.0 in Navigator 2.0
- JavaScript 1.5 is most recent
- JavaScript 2.0 in 2003
6JavaScript and ECMAScript
- JavaScript standardized by the ECMA TC39TG1
committee - ECMA 262
- ISO 16262
- JavaScript 1.5 ECMAScript Edition 3
- JavaScript 2.0 ECMAScript Edition 4
- TC39TG1 leading the design of Edition 4
7Outline
- Background
- Motivation
- Construct the JavaScript 2.0 language
- Process
- Conclusion
8JavaScript 2.0 Motivation
- Evolving programs
- Compatibility
- Modularity
- Safety
- Interoperability with other languages
- Simplify common patterns
- Class declarations
- Type declarations
- Attributes and conditional compilation
- Compatible with JavaScript 1.5
9Programming in the Large
- Programs written by more than one person
- Programs assembled from components (packages)
- Programs in heterogeneous environments
- Programs that use evolving interfaces
- Long-lived, evolving programs
10Non-Goals
- High-performance applications
- General language
- Language for writing huge programs
- Stripped-down version of existing language
11Outline
- Background
- Motivation
- Construct the JavaScript 2.0 language
- Process
- Conclusion
12JavaScript 2.0
13Scenario 1
Library
package Searcher public function find(x)
while (x gt 0) if (ax) return ax
else x - 2 return null
14Scenario 1
Library
Web page
package Searcher public function find(x)
while (x gt 0) if (ax) return ax
else x - 2 return null
import Searcher var c find(34) var d
find("42")
15Scenario 1
Library
Web page
package Searcher public function find(x) x
2 while ((x - 2) gt 0) if (ax)
return ax return null
import Searcher var c find(34) var d
find("42")
16Scenario 1
Library
Web page
package Searcher public function find(x) x
2 while ((x - 2) gt 0) if (ax)
return ax return null
import Searcher var c find(34) var d
find("42") // same as find(420)
17Solution Type Annotations
Library
Web page
package Searcher public function
find(x Integer) x 2 while ((x - 2) gt
0) if (ax) return ax return
null
import Searcher var c find(34) var d
find("42") // now same as find(42)
18Type Annotations
- Optional
- Strongly typed type annotations are enforced
- Not statically typed only dynamic type of an
expression matters
class A function f() class B extends A
function g()
var aA new B a.f() // OK a.g()
// OK var x new A // OKvar bB x
// Error
19JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
20Scenario 2
Library
Web page
package ColorLib var red 1 var green
2 var blue 4 function set(color) function
drawPoint(x,y)
import ColorLib set(red) drawPoint(3,8)
21Scenario 2
Library
Web page
package ColorLib var red 1 var green
2 var blue 4 function set(color) function
drawPoint(x,y)
import ColorLib set(red) red
blue drawPoint(3,8)
22Solution const
Library
Web page
package ColorLib const red 1 const green
2 const blue 4 function set(color)
function drawPoint(x,y)
import ColorLib set(red) red
blue drawPoint(3,8)
23JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
- const
24JavaScript 1.5 Hoists Declarations
Scenario 3
Equivalent Code
function f(x) if (g(x)) var a x3
b 18 else var b x var a
"Hello" return ab
function f(x) var a var b if (g(x))
a x3 b 18 else b x
a "Hello" return ab
25Hoisting Problems
Scenario 3
Equivalent Code
function f(x) if () const a
var bInteger else var bString
const a return ab
function f(x) const a ? var b? if
() a b else b
a return ab
26Solution Local Scoping
- const declarations are locally scoped
- Typed declarations are locally scoped
- Class member declarations are locally scoped
- Declarations with attributes are locally scoped
- That leaves plain var declarations
- Locally scoping would be an incompatible change
- Not locally scoped except in strict mode
27Solution Local Scoping
Scenario 3
function f(x) if () const a
var bInteger else var bString
const a return ab
28JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
- const
- Local scoping
- Strict mode
29Scenario 4
Library
Web page
package ColorLib function drawPoint(x,y)
import ColorLib drawPoint(3,8)
30Scenario 4
Library
Web page
package ColorLib function drawPoint(x,y)
import ColorLib drawPoint(3,8,true)
31Scenario 4
Library 1.1
Web page
package ColorLib function drawPoint( x, y,
color black)
import ColorLib drawPoint(3,8,true)
32Solution Argument Checking
- Calls to functions with typed arguments are
checked - Calls to functions with typed result are checked
- Arguments may be optional
- Use ... for variable argument lists
- That leaves plain, untyped function declarations
- Argument checking would be an incompatible change
- Not checked unless defined in strict mode
33Scenario 4
Library
Web page
package ColorLib function drawPoint(
xInteger, yInteger)
import ColorLib drawPoint(3,8,true)
34Named Function Parameters
- function f(a Integer, b 5, named c 17, named
d 3) - f(4)
- f(4, d6)
- Why is the named attribute needed?
35JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
- const
- Local scoping
- Strict mode
- Named and optional arguments
36Why Classes?
- Ubiquitous idiom, even in prototype-based
languages - Few users get it right in JS 1.5 with prototypes
- Difficult to evolve a program that uses
prototypes - Little knowledge of invariants
- Classes model cross-language interaction
- Basis for access control
- Potential efficiency gains
- One of most-requested features
37Class Definition Syntax
class Dance const kind var name String
static var count constructor function
start(partner, length Integer)
class Swing extends Dance var speed
Integer function acrobatics() Boolean
38Classes and Prototypes
- Classes and prototypes will co-exist
- Language avoids early-binding the decision of
whether to use classes or prototypes - Access syntax identical a.b, a"b"
- The dynamic keyword on a class enables its
instances to dynamically acquire new properties - Classes cant inherit from prototypes or vice
versa
39JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
- const
- Local scoping
- Strict mode
- Named and optional arguments
- Argument checking
- Classes
40Scenario 5
41 package BitTracker public class Data
public var author public var contents
function save() function store(d)
... storeOnFastDisk(d)
41
42 package BitTracker public class Data
public var author public var contents
function save() function store(d)
... storeOnFastDisk(d)
import BitTracker class Picture extends
Data function size() var
palette function orientation(d) if
(d.size().h gt d.size().v) return
"Landscape" else return "Portrait"
42
43 package BitTracker public class Data
public var author public var contents
public function size() function save()
function store(d) ... if (d.size()
gt limit) storeOnSlowDisk(d) else
storeOnFastDisk(d)
import BitTracker class Picture extends
Data function size() var
palette function orientation(d) if
(d.size().h gt d.size().v) return
"Landscape" else return "Portrait"
43
44 package BitTracker public class Data
public var author public var contents
public function size() function save()
function store(d) ... if (d.size()
gt limit) storeOnSlowDisk(d) else
storeOnFastDisk(d)
import BitTracker class Picture extends
Data function size() var
palette function orientation(d) if
(d.size().h gt d.size().v) return
"Landscape" else return "Portrait"
44
45 package BitTracker public class Data
public var author public var contents
public function ?() function save()
function store(d) ... if (d.?() gt
limit) storeOnSlowDisk(d) else
storeOnFastDisk(d)
import BitTracker class extends Data ?
45
46Non-Solutions
- Assume it wont happen
- It does, especially in DOM
- Have programmer detect/fix conflicts (C)
- Old web pages linked with new libraries
- Have compiler bind identifier to definition
(Java) - Programs distributed in source form
- Explicit overrides static type system (C)
- Doesnt work in dynamic languages
- Burden on library user instead of library
developer
47Solution Namespaces
- Each name is actually an ordered pair
namespaceidentifier - A use namespace(n) statement allows unqualified
access to ns identifiers within a scope - Default namespace is public
- Namespaces are values
48 package BitTracker public class Data
public var author public var contents
function save() function store(d)
... storeOnFastDisk(d)
import BitTracker class Picture extends
Data function size() var
palette function orientation(d) if
(d.size().h gt d.size().v) return
"Landscape" else return "Portrait"
48
49 package BitTracker namespace v2 use
namespace(v2) public class Data public var
author public var contents v2 function
size() function save() function
store(d) ... if (d.size() gt limit)
storeOnSlowDisk(d) else storeOnFastDisk(d)
import BitTracker class Picture extends
Data function size() var
palette function orientation(d) if
(d.size().h gt d.size().v) return
"Landscape" else return "Portrait"
49
50 package BitTracker namespace v2 use
namespace(v2) public class Data public var
author public var contents v2 function
size() function save() function
store(d) ... if (d.size() gt limit)
storeOnSlowDisk(d) else storeOnFastDisk(d)
import BitTracker use namespace(v2) class
Picture extends Data
function dims() var palette function
orientation(d) if (d.dims().h gt
d.dims().v) return "Landscape" else
return "Portrait" d.size()
50
51 package BitTracker explicit namespace v2 use
namespace(v2) public class Data public var
author public var contents v2 function
size() function save() function
store(d) ... if (d.size() gt limit)
storeOnSlowDisk(d) else storeOnFastDisk(d)
import BitTracker, namespace(v2) class
Picture extends Data
function dims() var palette function
size() function orientation(d) if
(d.dims().h gt d.dims().v) return
"Landscape" else return "Portrait"
51
52Versioning
- Namespaces distinguish between accidental and
intentional identifier matches - Library publisher annotates new functionality
with new namespaces - Web page imports a specific namespace
- Versioning affects name visibility only there
is only one library implementation
53Other Uses of Namespaces
- private, internal, etc. are syntactic sugars for
anonymous namespaces - Export private functionality to privileged
clients - Can use namespaces to add methods to an already
existing class (future feature)
54Property Lookup
55 class A function f() // fA class B extends
A function f() // fB class C extends B
function f() // fC
use namespace(public) c new C c.f() // fC
55
56 class A N function f() // fA class B
extends A N function f() // fB class C
extends B function f() // fC
use namespace(public) c new C c.f() //
fC use namespace(public) use
namespace(N) c new C c.f() // fB, not fC!
Lookup 2
56
57Property Lookup c.f
- Find highest (least derived) class that defines a
member f thats visible in the currently used
namespaces to pick a namespace n - Find lowest (most derived) definition of c.nf
- Gives object-oriented semantics
58JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
- const
- Local scoping
- Strict mode
- Named and optional arguments
- Argument checking
- Classes
- Namespaces, versioning, and protection
59Attributes
public var a v2 v3 v4 var x v2 v3 v4 function
y() v2 v3 v4 function z() public const
d v2 v3 v4 const c
60Attributes
Distributed Attributes
public var a v2 v3 v4 var x v2 v3 v4 function
y() v2 v3 v4 function z() public const
d v2 v3 v4 const c
public var a v2 v3 v4 var x function y()
function z() const c public const d
61Attributes
User-Defined Attributes
public var a v2 v3 v4 var x v2 v3 v4 function
y() v2 v3 v4 function z() public const
d v2 v3 v4 const c
const v2_4 v2 v3 v4 public var a v2_4 var
x v2_4 function y() v2_4 function z()
public const d v2_4 const c
62Attributes
- static debug v3 final foo(3) bar var xInteger
5 - Restricted expressions that evaluate to
- Built-in attributes such as final and static
- Namespaces
- true or false (conditional compilation)
- User-defined attributes
63Attributes
- const debug true
- static debug v3 final foo(3) bar var xInteger
5 - const A static debug v3
- A bar var yInteger
- private
- var z
- function f()
64JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
- const
- Local scoping
- Strict mode
- Named and optional arguments
- Argument checking
- Classes
- Namespaces, versioning, and protection
- Flexible attributes
65Additional Types
- sbyte, byte
- short, ushort
- int, uint
- Subsets of Number (IEEE double)
- All arithmetic done as though on Numberint(1e9)
int(1e9) ? 1e18
66Additional Types
- long, ulong
- Not subsets of Number
- Values distinct from mathematically equal Number
values, but coercable - Exactly represent all integers between -263 and
2641
67Additional Types
68Additional Types
- Sparse arrays as in JavaScript 1.5
- Dense arrays
- Typed arrays
69JavaScript 2.0
- JavaScript 1.5
- Packages
- Strong dynamic typing
- const
- Local scoping
- Strict mode
- Named and optional arguments
- Argument checking
- Classes
- Namespaces, versioning, and protection
- Flexible attributes
- Types for interacting with other languages
70Omitted Features
- Overloading
- Interfaces
- Units
- Operator overriding
- Wraparound integer arithmetic
- Lots of built-in libraries
71Strict Mode Revisited
- An implementation will run three kinds of
programs - JavaScript 1.5
- Run unchanged
- Non-strict JavaScript 2.0
- Almost all JavaScript 1.5 programs run unchanged
- Strict JavaScript 2.0
- Turns off troublesome quirks (scope hoisting,
newline dependencies, etc.)
72Strict Mode
- Variables must be declared
- Function argument checking
- Function declarations are immutable
- Semicolon insertion changes
73Outline
- Background
- Motivation
- Construct the JavaScript 2.0 language
- Process
- Conclusion
74Process
- JavaScript 1.0 developed at Netscape
- Later adopted by Microsoft
- Later standardized by ECMA
- JavaScript 1.5 developed and standardized
concurrently - JavaScript 2.0 design discussions occur mainly
within ECMA
75Tools
- ECMAScript standards use semantic descriptions of
the language - Use extended typed lambda calculus with
Algol-like syntax for ECMAScript Edition 4 - Wrote Common Lisp engine to
- Run and test grammar and semantics directly
- Auto-generate web page descriptions
- Auto-generate chapters of draft ECMAScript
standard - Freely available
76ListExpression? ? AssignmentExpression?
ListExpression? , AssignmentExpression? proc Vali
dateListExpression? (cxt Context, env Environm
ent) ListExpression? ? AssignmentExpression? do
ValidateAssignmentExpression?(cxt, env) ListEx
pression?0 ? ListExpression?1 , AssignmentExpressi
on? do ValidateListExpression?1(cxt, env) Vali
dateAssignmentExpression?(cxt, env) end proc p
roc EvalListExpression? (env Environment, phase
Phase) ObjOrRef ListExpression? ? AssignmentEx
pression? do return EvalAssignmentExpression?(e
nv, phase) ListExpression?0 ? ListExpression?1 ,
AssignmentExpression? do ra ObjOrRef ? EvalLis
tExpression?1(env, phase) readReference(ra, phas
e) rb ObjOrRef ? EvalAssignmentExpression?(env
, phase) return readReference(rb, phase) end proc
76
77Outline
- Background
- Motivation
- Construct the JavaScript 2.0 language
- Process
- Conclusion
78Availability
- Open source (NPL, GPL, or LGPL)
- JavaScript 1.5 in C or Java
- JavaScript 2.0 in C
- Compact, stand-alone sources
- Embed or run as a command line tool
79More Information
- www.mozilla.org/js/language
- Waldemar Horwat
- waldemar_at_acm.org