For instance, it seems to be like travelling back to the 80's just to have to live with the 'third element in the list containing the data about a person' instead of simply using person->name , I've gotten used to thinking in terms of symbols so much that I find it hard to go back to the kind of trickery that was 'normal' in say microsoft basic in the 80's because it lacked named elements in something akin to a struct.
There is a certain kind of elegance in something so minimal but it also comes with considerable mental overhead and opportunity for mistakes.
Most people don't do that, except in throwaway code. In CL you can use an alist, a plist, a struct, or CLOS.
I've gotten used to thinking in terms of symbols so much that I find it hard to go back
Given that Lisp's history with symbolic computing goes back to the beginning, something about that doesn't sound right.
Your person->name comment reminds me of something, by the way. Portions of our app run in both CL and JS (via the Parenscript library). This is relatively easy, although there are a few disagreements between the two that you have to watch out for (such as how they handle null). Anyway, there are lots of CL features we've "ported" to JS via macros, but there is also one JS feature I found myself envying so much that I finally wrote a partial implementation of it in CL. That is JS's willingness to allow you to stick any property on any object just by setting it. It's a rather Lispy feature since it's maximally dynamic and maximally flexible. I find it handy for incremental development. When you have some data about a thing that you want to associate with it, but only some of the time, it's a real pain to have to make a separate data structure to hold it and then make sure it gets passed alongside the original thing to all the appropriate places. Our CL implementation of this is pretty crude but it allows the important thing, which is that you can write (@ something :some-data) and (setf (@ something :some-data) "blah") pretty much wherever you want. So we can be said to have Greenspunned a bit of JS in Lisp!
(defstruct person
name age occupation) => PERSON
(make-person :name "Kris Kringle"
:age 71
:occupation "Santa") => #S(PERSON-1)
(person-name *) ==> "Kris Kringle"Don't worry, I realize that :)
> very real Lisp worth using has structures and objects:
That's a tricky and somewhat circular definition.
If it is worth using it is probably real and vv, but most lisp tutorials that teach 'pure' lisp do not have structures and / or objects, they rely on lists alone as their major data structure.
That also defines all lisps that do not have these items as somehow not real and there seem to be a lot of lisp people that somehow consider this 'impure'. Or is my reading material that dated ?
Go far a modern Lisp like Scheme. (You can ignore the syntax you don't want to deal with, yet.)
Usually it goes the other way around: you implement lists on top of defstruct.
But there is a danger in overusing structs and classes, too. You end up with these hugely complex ontologies for every little program, and frequently when you try to reuse code you end up with conflicts.
See http://research.microsoft.com/en-us/um/people/simonpj/papers... for some hints on writing a compiler for those (or just general amusement).