Is Clojure Simple?

[Tim Robinson]

So I've read the previous post > Rich Hickey: "Simple Made Easy" from
Strange Loop 2011, but I wanted to ask some simple questions not
complected by the interweaving path the other has post followed (is
'complected' even a word? - lol) .

I know the presentation was, while inclusive of Clojure, not specific
to Clojure and after having given some further thought I find myself
wondering where does Clojure sit in this continuum of simple to
complectness (ok, yes I am now making up words). And I wonder where
do the language designers think Clojure sits? How far along has
Clojure gone down this rabbit hole?

Is Rich planning to make a new language, because Clojure is 'here',
but not 'there' ? - and where is 'here' for Clojure anyway? If your
were to rank, in accordance to Rich's inventory of complect items, is
Clojure a 5/10? or a 9/10?

Do the Clojure language designers plan to make changes to Clojure to
make it simpler? And if so, how so?

I don't want this to be a battle on Clojure doing 'this' but not
'that' (and I hope that's possible).
Tim

[Sean Corfield]

On Sat, Oct 22, 2011 at 10:35 AM, Tim Robinson <tim.bl...@gmail.com> wrote:
> (is 'complected' even a word? - lol) .

OED: http://photo.pds.org:5004/view/Entry/37640?redirectedFrom=complect#eid

> Do the Clojure language designers plan to make changes to Clojure to
> make it simpler? And if so, how so?

This reminds me of the discussions on the C++ Standards Committee
about compatibility with C wherein Andrew Koenig coined the phrase "As
close as possible to C - but no closer"... perhaps Rich feels Clojure
is "as close as possible to simple - but no closer"? :)
--
Sean A Corfield -- (904) 302-SEAN
An Architect's View -- http://corfield.org/
World Singles, LLC. -- http://worldsingles.com/
Railo Technologies, Inc. -- http://www.getrailo.com/

"Perfection is the enemy of the good."
-- Gustave Flaubert, French realist novelist (1821-1880)

[David Powell]

Simplicity was described as being a property of the artefact, not the construct wasn't it?  So I'm not sure what it means exactly for Clojure to be simple or complex.

Does Clojure allow you to write artefacts that are simple?  Yeah, I think so, and I think it often makes it easier.

There was a table with the suggestions of simple replacements for more complex things - I think Clojure has pretty good coverage of those things.

I'm sure there will probably be improvements in the future that make things simpler still though - new ref types etc.

--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

[Laurent PETIT]

2011/10/22 Tim Robinson <tim.bl...@gmail.com>:

Since simple definition includes it being an objective property, then
if 'battles' start on this thread, this should be the smell that the
discussion changes to be about "easiness" rather than "simpleness" :-)

[Stuart Sierra]

I think Clojure is simple in design, complex in implementation. Dealing with the JVM introduces all sorts of complexity. Dealing with *hardware* introduces complexity. Perfection is only possible in the abstract. Compromises are always needed, and Clojure generally makes good ones. But there may be languages which make different compromises that offer an advantage in certain situations.

-Stuart Sierra
clojure.com

[Michael Jaaka]

Something is simple as long as your mental model is simple to track. Something which doesn't cause you headache.

If you can't build mental model in your head, then its definitely not simple.

Every time you think I have mental model which works like this, but before this I must remember about this and that,

or assume that there is something to add which behave like this, it is proof that it is doesn't solve problems in a simplest way.

All design patterns are proof of that used tools are not simple and must be made simple by applying as simple as possible additional mental model.

For example OO programming have a lot of design patterns.

When design pattern becomes mental model which solve specific problem and is not addition

to the goal but language feature then you can be sure that language is simple to such solve domain problems.

Now looking at Clojure which claims to be general purpose language, the Clojure is simple since it:

- allows you to turn design patterns into language features (as whole lisp)

- is near to mathematical logic (lambda, definition of functions - functions without side effect with which you can reason about)

- is practical since it is also about data manipulation (not a first time I have turned XML into s-expressions - interpretation, function definition, control flow you have out of box)

There are some also drawbacks about Clojure:

- there is no simple made currying so its not as near as for example Haskell to lambda calculus

- you can't reason about data types until runtime and empirically tests

- it is bound to JVM infrastructure (ClojureScript and CLR version want to change that)

There is a lot other fields in which Clojure doesn't fit, so its not simple in:

- real time systems (JVM is not real time cause of GC)

- hardware programming on low level (assemblers or C are much more suitable)

There is a lot other things to say about being simple but for now it should answer you question.

[Laurent PETIT]

2011/10/25 Michael Jaaka <michae...@googlemail.com>:

> Something is simple as long as your mental model is simple to
> track. Something which doesn't cause you headache.

Disagree. The whole point of Rich's talk is to have people not
conflate "simple" and "easy", or it seems to me that this is what
you're doing here.
"simple" is objective. You start talking about "your mental model is
simple to track" => you probably meant "easy to track". And anyway,
"your", "mental model" seems more like subjective material than
objective material.

[Christopher Burke]

Interesting discussion of this talk, including comments from Rich (or
at least someone claiming to be Rich):

http://www.reddit.com/r/programming/comments/lirke/simple_made_easy_by_rich_hickey_video/

On Oct 25, 7:00 am, Laurent PETIT <laurent.pe...@gmail.com> wrote:
> 2011/10/25 Michael Jaaka <michael.ja...@googlemail.com>:

[Olek]

Yes, Easy to track.
Nevertheless this definition passes Rich's list.

[Robert Levy]

This reminds me of the discussions on the C++ Standards Committee
about compatibility with C wherein Andrew Koenig coined the phrase "As
close as possible to C - but no closer"... perhaps Rich feels Clojure
is "as close as possible to simple - but no closer"? :)

In that case we've come full circle, because Koenig's phrase was a riff on Einstein's "Make things as simple as possible, but not simpler".