The point of Lisp is that you don't need to invent your own language. Just "defmacro" and get back to solving your real problem.

Just "defmacro" and get back to solving your real problem.

Learning isn't a real problem?

If you are just doing something for fun/learning, there is no need to release it to the world. I've written lots of programming languages, but I don't expect anyone to use them.

I don't see newbs learning Perl, Python, C++, Java, etc. by writing their own dialect or interpreter for them.

This language is more like C++ or Java than Lisp.

There's no need to keep it from the world either.

As for the parentheses, I don't see any excess.

    (let (foo bar) ...)

   (let ((foo 0)(bar 1)) ...)

   (let (foo nil bar nil) ...)

Edited to add: Another reason I like the ((var binding)...) syntax is because it keeps the core language as unambiguious as possible. If I want to have an Arc-like binding operator, I can just write one and use that:

   (my-let (foo 1 bar 2 baz 3) (+ foo bar baz)) ; ==> 6

  (let foo 0 ...)

certainly things can be renamed, but personally i feel that if you don't go the extra mile for your users, someone else will, and you probably don't deserve success

  (let (foo bar) nil ...)

  (eq (symbol-function 'map)
      (symbol-function 'common-lisp::mapcar))   ---> T

  (eq (symbol-function 'mapseq)
      (symbol-function 'common-lisp::map))      ---> T

Even simple stuff like doing, e.g.,

  (defmacro mvb (&rest args)
    `(multiple-value-bind ,@args))

Having said all that, however, I have written my own interpreter in C for my own Lispy language, which I continue to develop (and use a lot for real tasks).

And actually, SBCL is nearly as fast as C in many cases. So there's really no reason to not use CL, unless of course you don't like CL.

Every Lisp dialect has some high-level syntax, e.g. quote, CL reader macros, and Arc ssyntax. These obscure the relationship between code and the underlying AST, but the designers felt that the gain in readability was worth it.

How much syntax should there be? A hard question, but I think it would be good for Lisp to move in the "more" direction. Readability is one of the big problems I have with Lisp, and macros, while certainly useful, make up only a small fraction of my code.

But yes, I can't for the life of me understand why someone would want to use TwinLisp.

Um...C/Java syntax <i>and</i> the abilities of Common Lisp....and the webpage says s-expressions aren't needed to build macros....ummm...ok, could the author show us a few TwinLisp macros?

mac &infinite-loop (body) {

`do () { $@body }}

S-expressions are permissible, so maybe it would be best to stick to those until you wrap your head around this crazy infix notation.

Perhaps we could see a macro example just slightly more complex.