Different lisps focus on different things, but one thing they usually have in common is their s-expression syntax. The syntax (if (< 0 1) 2 3), for instance, will result in 2 in nearly every lisp. The syntax (if _ _ _) acts as a conditional expression, like "_ ? _ : _" in C, and the syntax (< _ _) is a call to the function named "<". In this way, every complicated expression is made up of lists of simpler expressions, until you get to simple expressions like 2 and 3 that don't need to be divided further.

Because s-expression syntax is based on of a data structure (the list) that's very common in programming, it's often easier to manipulate lisp code than other kinds of code. As a result, lisp programmers tend to manipulate code very freely. Instead of writing boilerplate code over and over, they'll write something that automatically expands their code into the boilerplate code they want.

This makes lisp languages great testing grounds for ideas that would require lots of boilerplate code in other languages. However, it also means coding in a lisp is a good way to explore a programming style all your own; lisps attract and nurture people who are likely to venture off and develop their own languages.

There are some lisps that are much more popular than the others. Namely, they're the Common Lisp and Scheme standards. There are many implementations of each of these. I'm not an expert, but I'll do what I can to describe them.

Common Lisp, which is pretty much the default lisp, is a standardized language that has a lot of things built into the standard. It supports OOP, certain implementations have performance competitive with C if you know what you're doing, and it has a nifty error handling model. People tend to use Emacs and SLIME for Common Lisp development, with ASDF to model dependencies between published packages.

Scheme is a standardized lisp that has a more idealistic philosophy. Whereas the Common Lisp standard is pretty humongous, the Scheme standards typically try to be as simple as possible while still being a practical basis for complex applications. Lots of people have made their own implementations of Scheme because it's so simple, and the Scheme community has grown based on the successes of various popular implementations. The large community also introduces a lot of complexity the original standards didn't manage, so the standards have been growing too, but I digress.

One example implementation of Scheme is Racket, formerly known as PLT Scheme. Racket doesn't focus on minimalism. Instead, it focuses on being a complete programming experience, with practical libraries and development tools, a runtime platform that's suitable for a very wide range of languages and applications to be built on, and a centralized package system (PLaneT).

This is where Arc comes in. Arc is a language of its own, with multiple implementations, but it isn't standardized, and the canonical implementation of Arc is written in Racket. It acts a bit like a scripting language for Racket, allowing many things to be done more conveniently than if they were written in Racket itself.

  (let ([var val]) ...)  ; Racket
  (let var val ...)      ; Arc
  
  ; Racket
  (cond [(a-is-true)  (do-b)]
        [(c-is-true)  (do-d)]
        [#\t          (do-else)])
  
  ; Arc
  (if (a-is-true)  (do-b)
      (c-is-true)  (do-d)
                   (do-else))

  (my-not (my-and (my-not a) (my-not b)))  ; Racket
  (my-not:my-and my-not.a my-not.b)        ; Arc