Hacker News Reader

Comment by phoe-krk | Hacker News Reader

Lisp isn't a functional programming language. It's multi-paradigm.

More importantly it isn’t statically typed (like F#, Haskell, etc)

Common Lisp has strong dynamic typing. Dynamic, because language runtime maintains type information; strong, because each object has its type and cannot be treated as an instance of another type.

True, but he was asking about static typing.

>More importantly it isn’t statically typed (like F#, Haskell, etc)

You can statically type variables (bindings) in Common Lisp if you want:

    (defun little-function (x y)
       (declare (type fixnum x y)) 
           (+ x y))

Although type checking is limited at compile time.

As well, dynamic typing is much less of an issue in Lisp than it is in most other dynamic languages because the debugging and error handling features are really that good; they pick up most of the slack that the less-present type system creates. It would still make a lot of static typing proponents uncomfortable, of course, because not nearly as much is being statically verified. I think that the reason people become so infatuated with static verification (and testing) (not that they're bad things or anything, but just the reason they get put on such a pedestal by some people) is frustration with languages like Python, Ruby, and Javascript, which all lack a lot of the tooling that Lisp or Smalltalk has to make working in a very dynamic environment not only tolerable, but preferable. People get frustrated with the lack of tooling around mainstream dynamic languages' dynamism and attribute it to being frustrated with the dynamism itself.

Reply on news.ycombinator.com