brain-dump TLDR: I like clojure's costs-to-benefits.. and it's successful
because it's what the industry needs.




I wouldn't say lisp family langs are the 'best' languages, but I would say
its tradeoffs maximize the power of the individual, which interests me
since I am one :-).

Talking about tradeoffs can get very verbose, but I find it helpful to make
an analogy for things like mutability/immutability as a number line.

Let's think of some tradeoffs and virtues, it's not always black/white or
bad/good:
regularity/expressiveness
type-safety/dynamicity
mutability/immutability
speed
code size (language implementation or generated)
'weight of an abstraction' (ie how hard/big is it to jump a level of
expressiveness)
orthogonality of feature-set (pay for what you use)
popularity
blub-ability (do you need to be an expert to program in it?)
team-suitability

Then we can start to think of it as quantities, a vector.
We can subjectively normalize these for orthogonality, eg.. for some
languages, some tradeoffs will interact more with others in practice, and
we can come up with a cost-model according to our usage.

Then programming in this language can be thought of as a projection
(dot-product) of our minds along this vector space over time.

These tradeoffs affect 'costs', ie time/money/effort.  There is a fixed
cost to learning clojure well enough (IME the time it takes to grok Joy of
Clojure, implementation details like core.clj and Compiler.java, learning
enough emacs to get by), and little recurring costs along the way (like how
hard it is to refactor something).

In my opinion, I love clojure because of the orthogonality of its
feature-set (design by decoupling) and because of the expressivity of lisp
itself, that outweighs everything else.  Its code has a high SNR because of
it.

I think s-expressions are the closest thing to how brains actually work, ie
it's an efficient way to 'project' at any level of abstraction, and the
cost of traversing abstractions up and down is low due to the regularity of
the syntax.  Scheme makes a good teaching language because there are
benefits to seeing the structure directly.  We know from experience that
restricting abstraction is bad (java).

So, I'm pretty satisfied with it, I might learn other languages for
specific use-cases, but I think time spent in lisp isn't wasted, since it's
easy to pull an abstraction out of anything repetitive, and we as users can
steal ideas from other languages more effectively without involvement from
compiler writers.  A new language becomes necessary when we have to revisit
core primitives, which we will be compelled to do once we identify certain
costs are too high for too many people.

People might have different ideals, use-cases or costs based on their
experience or situation.'

I think the curation approach of 'design by decoupling' turned out to be a
great idea simply because of the huge amount of stuff that's been written
by many people in isolation over the last decades.  If we took it to an
extreme, then it would also cease to be a good idea.  I think
C++/Java-style OO has already been taken as far as it needs to go.  We've
reached the point where the costs-to-benefits are well-understood and felt
to be lacking for many current and future use-cases.


On Fri, Dec 27, 2013 at 8:24 AM, Massimiliano Tomassoli
<kiuhn...@gmail.com>wrote:

> On Friday, December 27, 2013 7:31:25 PM UTC+1, Sean Corfield wrote:
>>
>> I'm not sure why you are less trusting of their
>> real world experiences than what your professors told you about
>> (theoretical) OOP...
>>
>
> First, someone said that OOP doesn't alleviate the problems that it's
> supposed to solve and this I don't believe.
> Then, someone else claimed that OOP is useless in presence of
> immutability. I don't agree with that. It would also imply that Scala's
> developers are just plain stupid.
> So I was under the impression that you were criticizing something you
> didn't fully understand.
> Also, it's difficult to trust someone who claim that LISP is the best
> language there is and everybody else is just stupid for not realizing that.
> I only tend to trust people who realize that their language is not perfect
> and is just one of the many languages available.
>
>  --
> --
> You received this message because you are subscribed to the Google
> Groups "Clojure" group.
> To post to this group, send email to clojure@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+unsubscr...@googlegroups.com
> For more options, visit this group at
> http://groups.google.com/group/clojure?hl=en
> ---
> You received this message because you are subscribed to the Google Groups
> "Clojure" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojure+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/groups/opt_out.
>

-- 
-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@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+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

Reply via email to