1Defining new methods for an existing class may seem strange to folks used to statically typed languages such as C++ and Java in which all the methods of a class must be defined as part of the class definition. But programmers with experience in dynamically typed object-oriented languages such as Smalltalk and Objective C will find nothing strange about adding new behaviors to existing classes.

2In other object-oriented languages, slots might be called fields, member variables, or attributes.

3As when naming functions and variables, it’s not quite true that you can use any symbol as a class name—you can’t use names defined by the language standard. You’ll see in Chapter 21 how to avoid such name conflicts.

5Another way to affect the values of slots is with the :default-initargs option to **DEFCLASS**. This option is used to specify forms that will be evaluated to provide arguments for specific initialization parameters that aren’t given a value in a particular call to **MAKE-INSTANCE**. You don’t need to worry about :default-initargs for now.

6Adding an :after method to **INITIALIZE-INSTANCE** is the Common Lisp analog to defining a constructor in Java or C++ or an method in Python.

7One mistake you might make until you get used to using auxiliary methods is to define a method on **INITIALIZE-INSTANCE** but without the :after qualifier. If you do that, you’ll get a new primary method that shadows the default one. You can remove the unwanted primary method using the functions **REMOVE-METHOD** and **FIND-METHOD**. Certain development environments may provide a graphical user interface to do the same thing.

9One consequence of defining a **SETF** function—say, (setf foo)--is that if you also define the corresponding accessor function, foo in this case, you can use all the modify macros built upon , such as **INCF**, **DECF**, **PUSH**, and **POP**, on the new kind of place.

10The “variable” names provided by **WITH-SLOTS** and **WITH-ACCESSORS** aren’t true variables; they’re implemented using a special kind of macro, called a symbol macro, that allows a simple name to expand into arbitrary code. Symbol macros were introduced into the language to support **WITH-SLOTS** and **WITH-ACCESSORS**, but you can also use them for your own purposes. I’ll discuss them in a bit more detail in Chapter 20.

11The Meta Object Protocol (MOP), which isn’t part of the language standard but is supported by most Common Lisp implementations, provides a function, class-prototype, that returns an instance of a class that can be used to access class slots. If you’re using an implementation that supports the MOP and happen to be translating some code from another language that makes heavy use of static or class fields, this may give you a way to ease the translation. But it’s not all that idiomatic.