• Introduction
  • Motivation
  • Problems
• Solution
  • Language
  • Implementation
• Conclusion

• Application development
• Web technologies
• JavaScript only

• Difficult to develop large applications

            function foo () {
              bar();
              var x = 1;
            }
          

            var foo;
            foo = function () {
              var x;
              bar();
              x = 1;
            }
          

            var foo = 1;
            function bar () {
              if (!foo)
                var foo = 10;
              return foo;
            }
            bar();
          

            var foo = 1;
            function bar () {
              var foo; // = undefined
              if (!foo)
                foo = 10;
              return foo;
            }
            bar(); // ⇒ 10 
          

• Compilers
• Examples
  • CoffeeScript
  • Dart (Google)
  • TypeScript (Microsoft)

• Parenscript (CL)
• ClojureScript (Clojure)
• Scheme2JS (Scheme)
• Gambit-JS (R5RS)

• Features
• Implementation complexity
• Compilation approach

• Performance
  • Missing optimizations
  • Unnecessary closures
• Interoperability

ClojureScript

            (let [x (try ... (catch ...))]
              ...)
          

            var x = (function(){
                       try { ... }
                       catch (...) { ... }
                     })();
          

Parenscript

            (setf x (let ((x 1))
                      x))
          

            x = (function () {
                   var x = 1;
                   return x;
                 })();
          

• Goals
  • Performance
  • Features
  • Expressiveness
• Inspired by Dylan

• Invented by Apple
• Based on Scheme, Common Lisp
• Single namespace, CLOS
• ALGOL-like syntax
• Hygienic rule-based macro system

• S-expression syntax
• Dylan special forms, standard functions
• Hygienic procedural macro system
• Module system

• Simplified
  • Collections
  • Condition system
  • Numerical tower
• Single inheritance and single dispatch

• Usage of native types
  • <object> ⇒ Object
  • <array> ⇒ Array
• Native calling convention
  • Rest argument
  • Keyword arguments

• Only modules
• Import/export definitions
• Namespace

• Single inheritance and single dispatch
• Based on prototypes
• Normal constructors
• Methods added to prototype

            (define-class <person> (<object>)
              (name ""))
             
            (define-method hello ((person <person>))
              (format-to-string "Hello, %s!"
                                (get person "name")))
          

            (define-class <student> (<person>)
              id)
             
            (define-method hello ((student <student>))
              (concatenate (call-next-method)
                (format-to-string " Student #%d!"
                                  (get student "id"))))
          

            (bind ((john (make <student>
                               name: "John" id: 23)))
              (hello john))
             
            ;; ⇒ "Hello, John! Student #23"
          

• Procedural, hygienic
• Inspired by Clojure
• Quasi-quotation
• Syntax-quoting

            (bind ((x 23))
              `(y x ,x ,'x))
          

            (foo::y bar::x 23 x)
          

• Prevent binding of external identifiers

            `(bind ((x ...)) ...
          

            (define-macro inc! (place value)
              `(set! ,place
                     (+ ,place ,(or value 1))))
          

            (bind ((x 1)
                   (+ -))
              (inc! x)
              x)
            ;; ⇒ 2