Hacker News Reader

Comment by nickik | Hacker News Reader

Clojure is much, much less complex then Scala and it is functional and OO. Many people see clojure as purly functional but clojure programmes are often designed in OO style as well.

OO here meaning polymorphism over types of your data 'object'. The diffrence is that you usally never mutate your object.

It is fair to say however that the emphasis of clojure is functional and your code is expected to be functional style, only when you really need it, you start adding polymorpism but even then protocolls are expected to be a implementation detail quite often. Also, we access our objects the same way we do our hashmaps and even the same function often work on both objects or hashmaps.

Some people might of course dislike this approche where OO is not really not used in the traditional way and is kind of pushed down. So clojure I would say, is techniclly multi-paradigm but culturally its not.

View on HN

We've had dynamic OO+FP languages for a very long time but only in the last 10 years have we seen them with static type systems. I really like clojure (though I haven't used it in anger) but I think you're wrong when it comes to complexity.

Complexity with dynamic languages grows with the size of the project. I know that because of the focus on purity & immutable data structures clojure mananges to mitigate this problem but I'm afraid it's still there.

The last few years several features have been added to clojure that increased the complexity(/surface area) of the language and the documentation is often a mess. I'm not a clojure hater, just pointing out that the complexity with clojure lies elsewhere.

edit: kinda forgot about Ocaml (~18 yrs old apparently)

> Complexity with dynamic languages grows with the size of the project.

I was talking about language complexity, not how complex the project is.

That said, I have nothing against static typing, my argument was not really about typing at all. It was more about how OO and functional interact in clojure compared to java. Also types by itself dont really make all that good of a documentation, at least not the kind you care about when looking something up in the internet.

I am a fan of schema, and I think the future really is in the combination of schema and core.typed. I dont really like to devlop with pre set types and structures, but you could with schema/core.typed. I prefer to work dynamiclly and once im happy with the shape of my data, I 'set it in stone' by writing the correct schema for it. Then you can just always validate everything during devlopment/staticlly. When you deploy you can turn on validation only for data from the outside. This is how I would like to do it, until schema and core.typed work together I just use schema.

There's nothing preventing you from using core.typed (http://typedclojure.org/) in Clojure. There's a presentation from CircleCI on how they use core.typed (http://blog.circleci.com/supporting-typed-clojure/) where it makes sense for their projects.

> Clojure is much, much less complex then Scala and it is functional and OO.

Until you need to decipher someone else's code full of NIH macros.

For the most part macros make most code much, much easier to read. The clojure compunity is also really fixed in its way, how and when macros are written.

Take one example, core.match. Now in a language that does not have pattern matching code that can be easly written with pattern matching is very hard to read. In clojure its very easy to read.

Now one might argue that a 'good' langauge should have support for pattern matching. To that I say, the language creators can never have all the features everybody wants, it will slow down devlopment of the language and increase complexity.

I would rather read one or two nice clojure macros that reduce tons of boilerplate as you would need in other languages. The same happens in other languages, for exmaple rust. I really enjoy using macros there as well. Give me a language with macros 100%, it improves read and write ability in the waste majority of cases.

I do like macros and Clojure.

My point is that there are many types of code complexity and abusing macros for your in-house DSL is one of them.

This happens a lot in many Lisp shops.

> Clojure is much, much less complex then Scala and it is functional and OO.

Yes, but it doesn't even have types! (Except clojure-typed, which is so cumbersome and verbose that it's faster to just write Java.)

If you really belive that core.typed makes clojure as verbose as Java then you have not looked at it. Also, its not like people use clojure over java because they dont have to write down types. There are tons of other reasons people use clojure.

Also, core.typed can do things that java can not.

> Yes, but it doesn't even have types!

While I understand what you mean, you should write down what you mean. Clojure has types, but not static typing.

> Also, core.typed can do things that java can not.

Isn't that a very low bar?

> Clojure has types, but not static typing.

Types are – by definition – static.

From what I've seen core.typed isn't all that much more verbose than Scala annotations and certainly a hell of a lot more readable.

  (defalias AnyMonad 
    "A monad with bind, result, and optionally zero and plus."
    (TFn [[m :< (TFn [[x :variance :covariant]] Any)]]
      '{:m-bind (All [x y]
                  [(m x) [x -> (m y)] -> (m y)])
        :m-result (All [x]
                    [x -> (m x)])
        :m-zero (U (All [x] (m x)) Undefined)
        :m-plus (U (All [x]
                     [(m x) * -> (m x)])
                   Undefined)}))

If you say so ...

not really sure what the problem here is...

Reply on news.ycombinator.com