CoffeeScript: less typing, bad readability(ceronman.com)

  foo or= 'bar'

    do_something(with, these, args) if im_supposed_to

    Coming from Python [...]
    
    For example, in C-like languages, you can omit curly brackets 
    after a conditional expression if you only have one statement:
    
      if (condition)
          action();
    
    But what happens if we add a new statement:
    
      if (condition)
          action();
          action2();

    Given that CoffeeScript doesn’t fix any of the fundamental problems of JavaScript

    action true
      option1: 1
      option2: 2

  options =
    a: 1
    b: 2
  action true, options

    doSomething ->
      return 'hello'

    doSomething -> 'hello'

    action = (token, i) ->
        @tokens.splice i, 0, @generate 'CALL_END', ')', token[2]

    moveTo 10,
      20
      10

    doSomething 1,
    2
    3
    4

    doSomething 1,
      2
        3
       4

    doSomething (->
    'hello'), 1

    somethingDo = (ms, func) ->
      doSomething func, ms

    somethingDo 1, ->
      'hello'



    action(key: value, option: value, otherValue)

    action {key: value}, {option: value}, otherValue


    x = {
      key1
      key2
      key3: value3
    }

    x = 1 if y != 0;

    if y isnt 0
      x = 1

  break for [tag], i in @tokens when tag isnt 'TERMINATOR'
  @tokens.splice 0, i if i

    filtered = []
    for token, i in tokens
      if not (i is 0 and token is 'TERMINATOR')
        filtered.push token


    i += block.call this, token, i, tokens while token = tokens[i]

    class Parser      
      block: (token) =>         
        @currentNode.push new Token(token)
      parse: =>
        for token in tokens
          @block token
        

    js = (parser.parse lexer.tokenize code).compile options

    tokens = lexer.tokenize code
    parsed = parser.parse tokens
    js = parsed.compile options

    Given that CoffeeScript doesn’t fix any of the
    fundamental problems of JavaScript

    coffeescript doesn't bring much to table

    string interpolation 
    multi-line strings
    comprehensions
    guarded loops (hasOwn...)
    easy constructor/prototype definition (class)
    avoiding global leaks/shadowing
    function binding
    splats, defaults
    safe usage of reserved names
    existential operator
    chained comparisons
    READABLE regular expressions

  - to write what I want to achieve
  - to write something that makes me feel creative
  - to write something that makes me feel tidy, organized
  - to write a syntax error
  - to write a logical error
  - to step into a "gotcha"
  - to find that bug
  - to grasp a short snipped
  - to grasp a 20K loc app
  - to read my own code 1 week later
  - to read my own code 3 years later
  - to read somebody else's code

   Javascritp + ruby  = coffeescript
   coffescript + perl = coco
   coco + haskell     = livescript