--- /dev/null
+! Copyright (C) 2008 Slava Pestov.
+! See http://factorcode.org/license.txt for BSD license.
+USING: slides help.markup math arrays hashtables namespaces
+kernel sequences parser memoize io.encodings.binary
+locals kernel.private help.vocabs assocs quotations
+urls peg.ebnf tools.annotations tools.crossref
+help.topics math.functions compiler.tree.optimizer
+compiler.cfg.optimizer fry ;
+IN: talks.google-tech-talk
+
+CONSTANT: google-slides
+{
+ { $slide "Factor!"
+ { $url "http://factorcode.org" }
+ "Development started in 2003"
+ "Open source (BSD license)"
+ "First result for \"Factor\" on Google :-)"
+ "Influenced by Forth, Lisp, and Smalltalk (but don't worry if you don't know them)"
+ }
+ { $slide "Language overview"
+ "Words operate on a stack"
+ "Functional"
+ "Object-oriented"
+ "Rich collections library"
+ "Rich input/output library"
+ "Optional named local variables"
+ "Extensible syntax"
+ }
+ { $slide "Example: factorial"
+ "Lame example, but..."
+ { $code "USE: math.ranges" ": factorial ( n -- n! )" " 1 [a,b] product ;" }
+ { $code "100 factorial ." }
+ }
+ { $slide "Example: sending an e-mail"
+ { $vocab-link "smtp-example" }
+ "Demonstrates basic stack syntax and tuple slot setters"
+ }
+ { $slide "Functional programming"
+ "Code is data in Factor"
+ { { $snippet "[ ... ]" } " is a block of code pushed on the stack" }
+ { "We call them " { $emphasis "quotations" } }
+ { "Words which take quotations as input are called " { $emphasis "combinators" } }
+ }
+ { $slide "Functional programming"
+ { $code "10 dup 0 < [ 1 - ] [ 1 + ] if ." }
+ { $code "10 [ \"Hello Googlers!\" print ] times" }
+ { $code
+ "USING: io.encodings.ascii unicode ;"
+ "{ \"tomato\" \"orange\" \"banana\" }"
+ "\"out.txt\" ascii ["
+ " [ >upper print ] each"
+ "] with-file-writer"
+ }
+ }
+ { $slide "Object system: motivation"
+ "Encapsulation, polymorphism, inheritance"
+ "Smalltalk, Python, Java approach: methods inside classes"
+ "Often the \"message sending\" metaphor is used to describe such systems"
+ }
+ { $slide "Object system: motivation"
+ { $code
+ "class Rect {"
+ " int x, y;"
+ " int area() { ... }"
+ " int perimeter() { ... }"
+ "}"
+ ""
+ "class Circle {"
+ " int radius;"
+ " int area() { ... }"
+ " int perimeter() { ... }"
+ "}"
+ }
+ }
+ { $slide "Object system: motivation"
+ "Classical functional language approach: functions switch on a type"
+ { $code
+ "data Shape = Rect w h | Circle r"
+ ""
+ "area s = s of"
+ " (Rect w h) = ..."
+ "| (Circle r) = ..."
+ ""
+ "perimeter s = s of"
+ " (Rect w h) = ..."
+ "| (Circle r) = ..."
+ }
+ }
+ { $slide "Object system: motivation"
+ "First approach: hard to extend existing types with new operations (open classes, etc are a hack)"
+ "Second approach: hard to extend existing operations with new types"
+ "Common Lisp Object System (CLOS): decouples classes from methods."
+ "Factor's object system is a simplified CLOS"
+ }
+ { $slide "Object system"
+ "A tuple is a user-defined class which holds named values."
+ { $code
+ "TUPLE: rectangle width height ;"
+ "TUPLE: circle radius ;"
+ }
+ }
+ { $slide "Object system"
+ "Constructing instances:"
+ { $code "rectangle new" }
+ { $code "rectangle boa" }
+ "Let's encapsulate:"
+ { $code
+ ": <rectangle> ( w h -- r ) rectangle boa ;"
+ ": <circle> ( r -- c ) circle boa ;"
+ }
+ }
+ { $slide "Object system"
+ "Generic words and methods"
+ { $code "GENERIC: area ( shape -- n )" }
+ "Two methods:"
+ { $code
+ "USE: math.constants"
+ ""
+ "M: rectangle area"
+ " [ width>> ] [ height>> ] bi * ;"
+ ""
+ "M: circle area radius>> sq pi * ;"
+ }
+ }
+ { $slide "Object system"
+ "We can compute areas now."
+ { $code "100 20 <rectangle> area ." }
+ { $code "3 <circle> area ." }
+ }
+ { $slide "Object system"
+ "New operation, existing types:"
+ { $code
+ "GENERIC: perimeter ( shape -- n )"
+ ""
+ "M: rectangle perimeter"
+ " [ width>> ] [ height>> ] bi + 2 * ;"
+ ""
+ "M: circle perimeter"
+ " radius>> 2 * pi * ;"
+ }
+ }
+ { $slide "Object system"
+ "We can compute perimeters now."
+ { $code "100 20 <rectangle> perimeter ." }
+ { $code "3 <circle> perimeter ." }
+ }
+ { $slide "Object system"
+ "New type, extending existing operations:"
+ { $code
+ "TUPLE: triangle base height ;"
+ ""
+ ": <triangle> ( b h -- t ) triangle boa ;"
+ ""
+ "M: triangle area"
+ " [ base>> ] [ height>> ] bi * 2 / ;"
+ }
+ }
+ { $slide "Object system"
+ "New type, extending existing operations:"
+ { $code
+ ": hypotenuse ( x y -- z ) [ sq ] bi@ + sqrt ;"
+ ""
+ "M: triangle perimeter"
+ " [ base>> ] [ height>> ] bi"
+ " [ + ] [ hypotenuse ] 2bi + ;"
+ }
+ }
+ { $slide "Object system"
+ "We can ask an object if its a rectangle:"
+ { $code "70 65 <rectangle> rectangle? ." }
+ { $code "13 <circle> rectangle? ." }
+ { "How do we tell if something is a " { $emphasis "shape" } "?" }
+ }
+ { $slide "Object system"
+ "We define a mixin class for shapes, and add our existing data types as instances:"
+ { $code
+ "MIXIN: shape"
+ "INSTANCE: rectangle shape"
+ "INSTANCE: circle shape"
+ "INSTANCE: triangle shape"
+ }
+ }
+ { $slide "Object system"
+ "Now, we can ask objects if they are shapes or not:"
+ { $code "13 <circle> shape? ." }
+ { $code "3.14 shape? ." }
+ }
+ { $slide "Object system"
+ "Or put methods on shapes:"
+ { $code
+ "GENERIC: tell-me ( obj -- )"
+ ""
+ "M: shape tell-me"
+ " \"My area is \" write area . ;"
+ ""
+ "M: integer tell-me"
+ " \"I am \" write"
+ " even? \"even\" \"odd\" ? print ;"
+ }
+ }
+ { $slide "Object system"
+ "Let's test our new generic word:"
+ { $code "13 <circle> tell-me" }
+ { $code "103 76 <rectangle> tell-me" }
+ { $code "101 tell-me" }
+ { { $link integer } ", " { $link array } ", and others are built-in classes" }
+ }
+ { $slide "Object system"
+ "Anyone can define new shapes..."
+ { $code
+ "TUPLE: parallelogram ... ;"
+ ""
+ "INSTANCE: parallelogram shape"
+ ""
+ "M: parallelogram area ... ;"
+ ""
+ "M: parallelogram perimeter ... ;"
+ }
+ }
+ { $slide "Object system"
+ "More: inheritance, type declarations, read-only slots, predicate, intersection, singleton classes, reflection"
+ "Object system is entirely implemented in Factor: 2184 lines"
+ { { $vocab-link "generic" } ", " { $vocab-link "classes" } ", " { $vocab-link "slots" } }
+ }
+ { $slide "Collections"
+ "Sequences (arrays, vector, strings, ...)"
+ "Associative mappings (hashtables, ...)"
+ { "More: deques, heaps, purely functional structures, disjoint sets, and more: "
+ { $link T{ vocab-tag f "collections" } } }
+ }
+ { $slide "Sequences"
+ { "Protocol: " { $link length } ", " { $link set-length } ", " { $link nth } ", " { $link set-nth } }
+ { "Combinators: " { $link each } ", " { $link map } ", " { $link filter } ", " { $link produce } ", and more: " { $link "sequences-combinators" } }
+ { "Utilities: " { $link append } ", " { $link reverse } ", " { $link first } ", " { $link second } ", ..." }
+ }
+ { $slide "Example: bin packing"
+ { "We have " { $emphasis "m" } " objects and " { $emphasis "n" } " bins, and we want to distribute these objects as evenly as possible." }
+ { $vocab-link "distribute-example" }
+ "Demonstrates various sequence utilities and vector words"
+ { $code "20 13 distribute ." }
+ }
+ { $slide "Unicode strings"
+ "Strings are sequences of 21-bit Unicode code points"
+ "Efficient implementation: ASCII byte string unless it has chars > 127"
+ "If a byte char has high bit set, the remaining 14 bits come from auxiliary vector"
+ }
+ { $slide "Unicode strings"
+ "Unicode-aware case conversion, char classes, collation, word breaks, and so on..."
+ { $code "USE: unicode" "\"ß\" >upper ." }
+ }
+ { $slide "Unicode strings"
+ "All external byte I/O is encoded/decoded"
+ "ASCII, UTF8, UTF16, EBCDIC..."
+ { $code "USE: io.encodings.utf8" "\"document.txt\" utf8" "[ readln ] with-file-reader" }
+ { "Binary I/O is supported as well with the " { $link binary } " encoding" }
+ }
+ { $slide "Associative mappings"
+ { "Protocol: " { $link assoc-size } ", " { $link at* } ", " { $link set-at } ", " { $link delete-at } }
+ { "Combinators: " { $link assoc-each } ", " { $link assoc-map } ", " { $link assoc-filter } ", and more: " { $link "assocs-combinators" } }
+ { "Utilities: " { $link at } ", " { $link key? } ", ..." }
+ }
+ ! { $slide "Example: soundex"
+ ! { $vocab-link "soundex" }
+ ! "From Wikipedia: \"Soundex is a phonetic algorithm for indexing names by sound, as pronounced in English.\""
+ ! "Factored into many small words, uses sequence and assoc operations, no explicit loops"
+ ! }
+ { $slide "Locals and lexical scope"
+ "Sometimes, there's no good stack solution to a problem"
+ "Or, you're porting existing code in a quick-and-dirty way"
+ "Our solution: implement named locals as a DSL in Factor"
+ "Influenced by Scheme and Lisp"
+ }
+ { $slide "Locals and lexical scope"
+ { "Define lambda words with " { $link POSTPONE: :: } }
+ { "Establish bindings with " { $link POSTPONE: [let } " and " { $snippet "[let*" } }
+ "Mutable bindings with correct semantics"
+ { "Named inputs for quotations with " { $link POSTPONE: [| } }
+ "Full closures"
+ }
+ { $slide "Locals and lexical scope"
+ "Two examples:"
+ { $vocab-link "lambda-quadratic" }
+ { $vocab-link "closures-example" }
+ }
+ { $slide "Locals and lexical scope"
+ "Locals are entirely implemented in Factor: 477 lines"
+ "Example of compile-time meta-programming"
+ "No performance penalty -vs- using the stack"
+ "In the base image, only 59 words out of 13,000 use locals"
+ }
+ { $slide "The parser"
+ "All data types have a literal syntax"
+ "Literal hashtables and arrays are very useful in data-driven code"
+ "\"Code is data\" because quotations are objects (enables Lisp-style macros)"
+ { $code "H{ { \"cookies\" 12 } { \"milk\" 10 } }" }
+ "Libraries can define new parsing words"
+ }
+ { $slide "The parser"
+ { "Example: URLs define a " { $link POSTPONE: URL" } " word" }
+ { $code "URL\" http://paste.factorcode.org/paste?id=81\"" }
+ }
+ { $slide "Example: memoization"
+ { "Memoization with " { $link POSTPONE: MEMO: } }
+ { $code
+ ": fib ( m -- n )"
+ " dup 1 > ["
+ " [ 1 - fib ] [ 2 - fib ] bi +"
+ " ] when ;"
+ }
+ "Very slow! Let's profile it..."
+ }
+ { $slide "Example: memoization"
+ { "Let's use " { $link POSTPONE: : } " instead of " { $link POSTPONE: MEMO: } }
+ { $code
+ "MEMO: fib ( m -- n )"
+ " dup 1 > ["
+ " [ 1 - fib ] [ 2 - fib ] bi +"
+ " ] when ;"
+ }
+ "Much faster"
+ }
+ { $slide "Meta-circularity"
+ { { $link POSTPONE: MEMO: } " is just a library word" }
+ { "But so is " { $link POSTPONE: : } }
+ "Factor's parser is written in Factor"
+ { "All syntax is just parsing words: " { $link POSTPONE: [ } ", " { $link POSTPONE: " } }
+ }
+ { $slide "Extensible syntax, DSLs"
+ "Most parsing words fall in one of two categories"
+ "First category: literal syntax for new data types"
+ "Second category: defining new types of words"
+ "Some parsing words are more complicated"
+ }
+ { $slide "Parser expression grammars"
+ { { $link POSTPONE: EBNF: } ": a complex parsing word" }
+ "Implements a custom syntax for expressing parsers"
+ { "Example: " { $vocab-link "printf-example" } }
+ { $code "\"cheese\" \"vegan\" \"%s is not %s\\n\" printf" }
+ { $code "\"Factor\" 5 \"%s is %d years old\\n\" printf" }
+ }
+ { $slide "Input/output library"
+ "One of Factor's strongest points: portable, full-featured, efficient"
+ { $vocab-link "io.files" }
+ { $vocab-link "io.launcher" }
+ { $vocab-link "io.monitors" }
+ { $vocab-link "io.mmap" }
+ { $vocab-link "http.client" }
+ "... and so on"
+ }
+ { $slide "Example: file system monitors"
+ { $code
+ "USE: io.monitors"
+ ""
+ ": forever ( quot -- ) '[ @ t ] loop ; inline"
+ ""
+ "\"/tmp\" t <monitor>"
+ "'[ _ next-change . ] forever"
+ }
+ }
+ { $slide "Example: time server"
+ { $vocab-link "time-server" }
+ { "Demonstrates " { $vocab-link "io.servers" } " vocabulary, threads" }
+ }
+ { $slide "Example: what is my IP?"
+ { $vocab-link "webapps.ip" }
+ "Simple web app, defines a single action, use an XHTML template"
+ "Web framework supports more useful features: sessions, SSL, form validation, ..."
+ }
+ { $slide "Example: Yahoo! web search"
+ { $vocab-link "yahoo" }
+ { "Demonstrates " { $vocab-link "http.client" } ", " { $vocab-link "xml" } }
+ }
+ { $slide "Example: simple web browser"
+ { $vocab-link "webkit-demo" }
+ "Demonstrates Cocoa binding"
+ "Let's deploy a stand-alone binary with the deploy tool"
+ "Deploy tool generates binaries with no external dependencies"
+ }
+ { $slide "Example: environment variables"
+ { $vocab-link "environment" }
+ "Hooks are generic words which dispatch on dynamically-scoped variables"
+ { "Implemented in an OS-specific way: " { $vocab-link "environment.unix" } ", " { $vocab-link "environment.windows" } }
+ }
+ { $slide "Example: environment variables"
+ "Implementations use C FFI"
+ "Call C functions, call function pointers, call Factor from C, structs, floats, ..."
+ "No need to write C wrapper code"
+ }
+ { $slide "Implementation"
+ "VM: 12,000 lines of C"
+ "Generational garbage collection"
+ "core: 9,000 lines of Factor"
+ "Optimizing native code compiler for x86, PowerPC"
+ "basis: 80,000 lines of Factor"
+ }
+ { $slide "Compiler"
+ { "Let's look at " { $vocab-link "benchmark.mandel" } }
+ "A naive implementation would be very slow"
+ "Combinators, currying, partial application"
+ "Boxed complex numbers"
+ "Boxed floats"
+ { "Redundancy in " { $link absq } " and " { $link sq } }
+ }
+ { $slide "Compiler: front-end"
+ "Builds high-level tree SSA IR"
+ "Stack code with uniquely-named values"
+ "Inlines combinators and calls to quotations"
+ { $code "USING: compiler.tree.builder compiler.tree.debugger ;" "[ c pixel ] build-tree nodes>quot ." }
+ }
+ { $slide "Compiler: high-level optimizer"
+ "12 optimization passes"
+ { $link optimize-tree }
+ "Some passes collect information, others use the results of past analysis to rewrite the code"
+ }
+ { $slide "Compiler: propagation pass"
+ "Propagation pass computes types with type function"
+ { "Example: output type of " { $link + } " depends on the types of inputs" }
+ "Type: can be a class, a numeric interval, array with a certain length, tuple with certain type slots, literal value, ..."
+ "Mandelbrot: we infer that we're working on complex floats"
+ }
+ { $slide "Compiler: propagation pass"
+ "Propagation also supports \"constraints\""
+ { $code "[ dup array? [ first ] when ] optimized." }
+ { $code "[ >fixnum dup 0 < [ 1 + ] when ] optimized." }
+ { $code
+ "["
+ " >fixnum"
+ " dup [ -10 > ] [ 10 < ] bi and"
+ " [ 1 + ] when"
+ "] optimized."
+ }
+ }
+ { $slide "Compiler: propagation pass"
+ "Eliminates method dispatch, inlines method bodies"
+ "Mandelbrot: we infer that integer indices are fixnums"
+ "Mandelbrot: we eliminate generic arithmetic"
+ }
+ { $slide "Compiler: escape analysis"
+ "We identify allocations for tuples which are never returned or passed to other words (except slot access)"
+ { "Partial application with " { $link POSTPONE: '[ } }
+ "Complex numbers"
+ }
+ { $slide "Compiler: escape analysis"
+ { "Virtual sequences: " { $link <slice> } ", " { $link <reversed> } }
+ { $code "[ <reversed> [ . ] each ] optimized." }
+ { "Mandelbrot: we unbox " { $link curry } ", complex number allocations" }
+ }
+ { $slide "Compiler: dead code elimination"
+ "Cleans up the mess from previous optimizations"
+ "After inlining and dispatch elimination, dead code comes up because of unused generality"
+ { "No-ops like " { $snippet "0 +" } ", " { $snippet "1 *" } }
+ "Literals which are never used"
+ "Side-effect-free words whose outputs are dropped"
+ }
+ { $slide "Compiler: low level IR"
+ "Register-based SSA"
+ "Stack operations expand into low-level instructions"
+ { $code "[ 5 ] regs." }
+ { $code "[ swap ] regs." }
+ { $code "[ append reverse ] regs." }
+ }
+ { $slide "Compiler: low-level optimizer"
+ "5 optimization passes"
+ { $link optimize-cfg }
+ "Gets rid of redundancy which is hidden in high-level stack code"
+ }
+ { $slide "Compiler: optimize memory"
+ "First pass optimizes stack and memory operations"
+ { "Example: " { $link 2array } }
+ { { $link <array> } " fills array with initial value" }
+ "What if we immediately store new values into the array?"
+ { $code "\\ 2array regs." }
+ "Mandelbrot: we optimize stack operations"
+ }
+ { $slide "Compiler: value numbering"
+ "Identifies expressions which are computed more than once in a basic block"
+ "Simplifies expressions with various identities"
+ "Mandelbrot: redundant float boxing and unboxing, redundant arithmetic"
+ }
+ { $slide "Compiler: dead code elimination"
+ "Dead code elimination for low-level IR"
+ "Again, cleans up results of prior optimizations"
+ }
+ { $slide "Compiler: register allocation"
+ "IR assumes an infinite number of registers which are only assigned once"
+ "Real CPUs have a finite set of registers which can be assigned any number of times"
+ "\"Linear scan register allocation with second-chance binpacking\""
+ }
+ { $slide "Compiler: register allocation"
+ "3 steps:"
+ "Compute live intervals"
+ "Allocate registers"
+ "Assign registers and insert spills"
+ }
+ { $slide "Compiler: register allocation"
+ "Step 1: compute live intervals"
+ "We number all instructions consecutively"
+ "A live interval associates a virtual register with a list of usages"
+ }
+ { $slide "Compiler: register allocation"
+ "Step 2: allocate registers"
+ "We scan through sorted live intervals"
+ "If a physical register is available, assign"
+ "Otherwise, find live interval with furthest away use, split it, look at both parts again"
+ }
+ { $slide "Compiler: register allocation"
+ "Step 3: assign registers and insert spills"
+ "Simple IR rewrite step"
+ "After register allocation, one vreg may have several live intervals, and different physical registers at different points in time"
+ "Hence, \"second chance\""
+ { "Mandelbrot: " { $code "[ c pixel ] regs." } }
+ }
+ { $slide "Compiler: code generation"
+ "Iterate over list of instructions"
+ "Extract tuple slots and call hooks"
+ { $vocab-link "cpu.architecture" }
+ "Finally, we hand the code to the VM"
+ { $code "\\ 2array disassemble" }
+ }
+ { $slide "Garbage collection"
+ "All roots are identified precisely"
+ "Generational copying for data"
+ "Mark sweep for native code"
+ }
+ { $slide "Project infrastructure"
+ { $url "http://factorcode.org" }
+ { $url "http://concatenative.org" }
+ { $url "http://docs.factorcode.org" }
+ { $url "http://planet.factorcode.org" }
+ "Uses our HTTP server, SSL, DB, Atom libraries..."
+ }
+ { $slide "Project infrastructure"
+ "Build farm, written in Factor"
+ "12 platforms"
+ "Builds Factor and all libraries, runs tests, makes binaries"
+ "Saves us from the burden of making releases by hand"
+ "Maintains stability"
+ }
+ { $slide "Community"
+ "#concatenative irc.freenode.net: 50-60 members"
+ "factor-talk@lists.sf.net: 180 subscribers"
+ "About 30 people have code in the Factor repository"
+ "Easy to get started: binaries, lots of docs, friendly community..."
+ }
+ { $slide "Future direction: Factor 1.0"
+ "Continue doing what we're doing:"
+ "Polish off some language features"
+ "Stability"
+ "Performance"
+ "Documentation"
+ "Developer tools"
+ }
+ { $slide "Future direction: Factor 2.0"
+ "Native threads"
+ "Syntax-aware Factor editor"
+ "Embedding Factor in C apps"
+ "Cross-compilation for smaller devices"
+ }
+ { $slide "That's all, folks"
+ "It is hard to cover everything in a single talk"
+ "Factor has many cool things that I didn't talk about"
+ "Put your prejudices aside and give it a shot!"
+ }
+ { $slide "Questions?" }
+}
+
+: google-talk ( -- )
+ google-slides "Google Tech talk" slides-window ;
+
+MAIN: google-talk
projects / factor-talks.git / blobdiff