John Carmack working on Scheme as a VR scripting language(groups.google.com)

  (define (print something)
    (display something)
    (newline))

  (define (hello)
    (print "Hello world"))

    (function (){ // let introduces new scope
      var hello0 = function (){ // hello0 is a variable holding an anonymous function
        return console.log("Hello world"); 
      };
      return hello0();
    })();

    (define (hello) (displayln "Hello world"))
    (hello)

    (define (hello)
      (displayln "Hello, World!"))
    
    (hello)

  (defn hello [] (println "hello world"))
  (hello) ;; in Clojure

  (defun hello () (format t "hello world"))
  (hello) ;; in Common Lisp.

    (let ([hello-func (lambda ()
		        (displayln "Hello world!"))])
      (hello-func))

    (let [hello (fn [] 
                  (println "Hello World"))]
      (hello))

    (defn hello []
      (println "Hello World"))

    (hello)

  ( http://docs.racket-lang.org/ )

    foo = { x = 1, y = 2 }
    mt = { __index = bar }
    setmetatable(foo, mt)

    foo := { _proto: bar, x: 1, y: 2 }

  Dan Liebgold from Naughty Dog Software in Santa Monica then came on stage with the
  first gaming related talk at CUFP. They produce the popular Uncharted game series for the
  Playstation, which is famous for its complex and interactive scripted scenes. Dan described
  modern game development as a major production effort where, roughly, artists produce
  data and programmers produce code.
  Naughty Dog has a history of using various Lisp dialects to handle the code and data in
  a unified way. But when making the jump from the Playstation 2 to the Playstation 3, they
  decided that maintaining a custom Lisp-based game development system was too costly,
  and instead dedicated their efforts to rebuilding the tools, engine, and game in C++ and
  assembly language.
  This decision left no scripting system for gameplay and, more importantly, no system
  for creating DSLs and the extensive glue data that is typically required to develop a major
  video game. There was no off-the-shelf scripting system that fit the stringent memory
  requirements in a Playstation 3, and no language that would allow rapid DSL creation
  that fit into the existing tool chain.
  With a bit of naivety, a penchant for the Scheme language, and a passion for functional
  programming techniques, the team dove in and put together a system to fill in the gaps!
  They used mzScheme, which can compile to fast native code. Dan reported that the results
  have been very good, but not without issues. In particular, garbage collector performance
  sometime led to manual tuning being required, and build environment integration was
  tricky. Syntax transformations and error reporting led to confusion with new programmers
  too.
  On the other hand, the functional nature of the system was a big win, as it allowed
  them to flexibly distill game data down to just the right form to embed into the resource-
  constrained run-time environment. The final result is a system where programmers, artists,
  animators, and designers are productively programming directly in an S-expression Scheme-
  like language. Dan closed his talk by wowing the audience with the trailer for the game,
  which has now been released and is garnering extremely positive reviews.