Re: [tlug] "Go Considered Harmful"

[Josh Glover <jmglov@example.com>]

On Wed, 2 Sep 2020 at 07:45, Curt J. Sampson <cjs@example.com> wrote:

Well, not really. Lack of a good type system really hurts it.

I'm really not convinced by this argument. Strong type systems look great on paper, but I personally haven't seen that they make my code better or safer. I really think it boils down to preference; some people's minds seem to gravitate towards strong typing, and others enjoy being able to shape the Matrix as they see fit. ;)

Nada Amin made a really interesting point about this in a talk at EuroClojure a few years back. She uses both Clojure and Scala, and she said that she prefers Scala when she's writing a program like a compiler where she knows exactly how to solve the problem, but Clojure when she's doing either exploratory programming or trying to solve a problem that she doesn't know the solution too yet. She said that she appreciates the type system eliminating certain kinds of errors she would otherwise make, but that matters a lot more in the case that she's implementing a known solution.

And most Lisp dialects (Scheme being a notable exception) have a lot of baggage that
seems to me not really to justify its weight, such as the famous `DO` and,
arguably, separate namespaces for function variables and non-function
variables. (Clearly I fall on the Scheme side in this argument. :-))

I'm a Scheme / LISP-1 person all the way, so I'm with you here. :)

 

And sometimes the Best Langauge Ever for what you want to do is not
directly expressing an AST.

Haha, true. I guess this is where Common Lisp really shines; those people drank deeply of the macro Kool-Aid. Reader macros let you mold Lisp into non-AST forms. I think most Scheme dialects also have reader macros, right? Clojure emphatically does not, which I actually like. Clojure, oddly enough for a Lisp, discourages the use of macros (in the sense that the community does; the language doesn't make macros harder than Scheme). The rule of thumb in Clojure is data structures over functions, and functions over macros.

> I don't have anything of value to add to this really interesting thread,
> but no Lisp fans were popping up to mention how awesome it is, so...

Yeah, Lisp does have certain awesome things. It looks to me like the macro
system in Lisp works better than what's available for Haskell, for example,
and there doesn't seem to be any easy way around that.

Exactly. It's hard to see how a macro system in a non-raw AST language can ever be as easy as one where you're just directly manipulating the AST.

 

I'd expected Steve to come in on the Lisp side of things, but it appears he
may have gone to the Dark Side of "ALGOL-like or nothing." :-)

Maybe Steve has lost his edge... ;-P

--

Cheers,
Josh