Every move to a higher level programming language is just a layer of syntactic sugar converting the language constructs back to a lower level language.

So from this perspective, syntactic sugar is needed for all languages, the interesting problem is finding out what syntactic sugar is best suited for a given purpose.

The argument that I try to make comes precisely from the opposite direction of imperative programming: Comes from logic programming.

I don’t know where I fail to get that message across. But considering that I hardly refer Java, I am starting to suspect some people read what they want to read, and not what I trying to transmit.

Lisp obviously suffers from the same problem as Prolog: As it is really a nice and elegant solution, it tends to breed some level of arrogance. Understandable, but self-destructive at the end.

Infix math expressions go back decades in Lisp… they’re easy to implement. Most Lisp programmers don’t give two hoots and a holler for them, though.

Anyway Lisp is deep, deeper than syntax. I think people are generally taught imperative programming, not applicative.

Lisps tend to have better support for various mathematics than the curly-braced languages to boot, when it comes to semantics, richness, and accuracy.

Whatever.

+(2,3,X) – equivalent to (+ 2 3)
2 + 3.

Note full flexibility and freedom to choose your style with the :- op built-in . And at very little cost in parser complexity. No hard-coded operators at all.

Why NOT have it? If it’s a nice benefit on occasion, why not? Divvy out your problems between ones that can be attacked in a massively parallel way, those that can use GPU, those that just need brute CPU strength, and deal with them accordingly.

It sounds like extrapolation from one data point to say “i don’t need it, so why does everyone else?” which is the basic vibe from point 1. Why would you need a fast laptop? You don’t seem to. But many people want one. Wouldn’t you want an Ion, or Ion 2 in your netbook? Or maybe an SSD would speed it up?

There’s a fundamental difference between individual user’s needs, and their desires, their wants. The majority of netbook users would i’d argue want a faster netbook. They’re sucky slow. Concurrency might be in parts hard, but sometimes it’s pretty easy, and getting easier.

Concurrency, having the CPU GPU memory HD, SSD firepower is relevant when the problem can be tackled this way. And when it is, it’s hugely important, as the gains are manyfold. It’s not the general be all and end all, but if a user could have a more powerful computer, wouldn’t they take it? has there really been many cases of “excessive” or too much computational power?

Would many people go back to single core? Or integrated over discrete graphics power? The need/desire of a user for more computational power isn’t a fixed value, and i’d imagine it’s going up , with day to day variations, all the time.

Here’s why:

Try the following

(contains? ['a 'b] 0) => true
(contains? ['a 'b] 2) => false

(contains? {:1 ‘a :2 ‘b} :1) => true
(contains? {:1 ‘a :2 ‘b} :3) => false

Contains? performs the following test: “for a given collection does the given key exist?”. For the first two calls, since vectors are keyed by their indices, the second argument is an index. Hence, the indices 0 and 1 exist. The index 2 does not.

Similarly for the map, the key :1 exists. The key :3 does not.

For a list, there is no defined key so a test of the form (contains? key) always returns false. You do have a point in that it might have been better if an exception of something like KeyUndefinedForCollectionException was thrown…

Sadly, for list membership, I have resorted to dropping down into the java contains method (using the dot operator) as follows:

(.contains ‘(a b) ‘a) => true
(.contains ‘(a b) ‘c) => false
(.contains (list ‘a ‘b) ‘a) => true
(.contains (list ‘a ‘b) ‘c) => false

Yup. Kind of confusing…..