Hacker News Reader

Comment by _hzrk | Hacker News Reader

SML over lisp:

* Doesn't have macros, which in my 16 years of experience is a plus, macros pollute, should at most be an implementation detail

* Has types

* Doesn't have parantheses and the annoying prefix notation

* Your knowledge of SML can be translated easily to OCaml, Java, Scala, which are more or less part of the same family

SML over Rust:

* I don't have to reason about lifetimes, I'm not in a constrained environment

* TCO (tail call optimization)

* At its core, Rust is still an imperative language, it was influenced by ML but not that much as many believe

SML over Scala:

* It doesn't suffer of Haskellism and Extreme Bipolarity (oop/fp) and gets the job done.

View on HN

> * Doesn't have macros

> * Has types

Your words betray your ignorance. Common Lisp has a type system. Have you ever written it? Do you actually know anything about it? Moreover, macros are a plus - you clearly have not actually used Lisp macros, which are categorically different than macros in other languages.

> * Doesn't have parantheses and the annoying prefix notation

Spelling mistake. Additionally, the parenthesized syntax is a choice, and one that you get used to quickly. Subjective, and therefore not valid as one of the items you listed.

> * Your knowledge of SML can be translated easily to OCaml, Java, Scala, which are more or less part of the same family

Meanwhile, knowledge of Common Lisp transfers to almost every dynamically-typed language ever made, and a good many static ones - including Java and Scala - because Lisp influenced all of those languages. That is, Lisp knowledge transfers to far more languages than SML knowledge does.

> Your words betray your ignorance. Common Lisp has a type system. Have you ever written it? Do you actually know anything about it? Moreover, macros are a plus - you clearly have not actually used Lisp macros, [...]

This isn't really okay. It's fine if you disagree, but I don't get why such aggression is needed.

I specifically avoided insulting them. "Ignorance" is not an insult; it's a description of your knowledge on a topic, and if it isn't the right word to describe telling such a blatant and fundamental misunderstanding, then what is?

Ok, I don't want to start a language war again, when I say types, I mean the modern reference to the word that it has a static type system. Indeed, Lisp languages are strongly typed but I'm sorry, in the real world it doesn't help me, I need types, statically checked types.

I don't know if Lisp, the language, influenced Java and Scala so much, it was more about its runtime, the garbage collector, etc. The only thing that I liked about Lisp is the composabiltiy, and coupled with objects from Simula created my favorite industrial languages, Java and TypeScript. I'm passionate about parsers, compilers and transformers and this is why I have a fost spot for SML, OCaml. I simply dislike Lisp, interesting language but not for me.

> when I say types, I mean the modern reference to the word that it has a static type system

Can you show me a significant body of literature or a whole community that uses "types" to mean "a strong type system"? Because I've never heard that aliasing done before.

> I don't know if Lisp, the language, influenced Java and Scala so much, it was more about its runtime, the garbage collector, etc.

Lisp pioneered lambdas and first-class functions, in addition to garbage collection, all of which were adopted by Scala and Java later.

> I simply dislike Lisp, interesting language but not for me.

I understand! I have things that I like and dislike, too. However, it's extremely frustrating when you ask for an analytical comparison between several languages, and some random person lacking knowledge on at least one of the languages (I suspect you don't know Rust either) comes in and, instead of actually providing relevant information, gives fallacies and opinions.

All languages associate types to expressions. But, all dynamic languages can have only one type for expressions. Indeed, dynamic languages associate types to values all the time but there is no static distinction. What people from dynamic languages are calling "types" are in fact runtime tags. What makes Lisp strongly typed are those runtime tags that prevent implicit conversions at runtime, something that JavaScript lacks.

In Common Lisp objects are values, so runtime tags are attached to data objects => which are actually values => which are stored in variables => which are not typed.

You can make it optionally typed at compile time to help the compiler but that means to annotate your code with 'type' keyword and it's verbose. The compiler does not enforce it.

Again, I've never seen this distinction made before. Please show me a body of literature that claims that dynamically typed languages do not have a type system - your claims on their own do not convince me.

Reply on news.ycombinator.com