Yes, probably easier than most languages, in fact.  The classic ST80 image,
which is still living inside Squeak (www.squeak.org) has the entire compiler
written in Smalltalk.

You can even create anonymous classes and give them behavior, then instantiate
them.  For example:

       | myClass myInstance |
       myClass := Behavior new. "create anon behavior"
       myClass compile: 'theAnswer ^42'. "add a method for instances"
       myInstance := myClass new. "create an instance"
       Transcript show: myInstance theAnswer; cr. "shows 42"

So, yeah.  metaprogramming is definitely Smalltalk's playground.

patch: aClass selector: aSelectorSymbol prepending: aStringNewStatement identifiedBy:
aSymbol
        "Append a statement to the end of a method, or just before the last return
(^) if one exists"

        | postNode methodParseTree patched |
        methodParseTree := aClass parseTreeFor: aSelectorSymbol.

        postNode := SmalltalkParser parseExpression: aStringNewStatement.

        self addPatchedNode: postNode firstIn: methodParseTree body identifiedBy:
aSymbol.

        patched  := self compileChangesFor: aSelectorSymbol in: aClass with: methodParseTree.

where #addPatchedNode:... ultimately calls a method like this:

You already received some very technical info about how code is
generated at runtime but since you are new to smalltalk here the info
that is most interesting for you:
First get Squeak from squeak.org to try the following examples.

In Smalltalk everything is an object, even classes.
Everything can be looked at and manipulated at runtime.
For example in a workspace write the following in a fresh line:
    Morph new explore.
and then do-it by pressing alt-d.
you have an explorer on the new Morph object.
you can manipulate it at runtime: write in the textpane of the explorer:
    self color: Color red.       then do-it by pressing alt-d.
Adding dynamic behavior:  again in the text-pane of the explorer
self on: #mouseUp send: #value to: [self color: Color random].
you have added behavior to your already-in-existence-object.

"generating code at runtime" is very easy.
The Funny thing is e.g. in squeak you are always(!) doing exactly that,
when writing code (a method or a block(lambda)) you are in fact inside a
running smalltalk program, the squeak-image.
All Behavior you want an object to have is defined in its class (and
superclasses), so if you want to add behavior(code) you can use a
class-browser BUT if you e.g. really want to as you put it "write code
which generates code" you can do the following: write a class-name,
write compile:, then write a string like so: (in any text-panel, then do-it)
Object compile: 'sayHi Speaker man say: ''hi'' '.
You have just created a method sayHi that makes all objects able to
respond to a message sayHi. e.g. try:
1 sayHi
The number one just said hi through your speakers.
This was the specific example of how you translate (at runtime) a string
into code for dynamic behavior of objects.
You can change the String into whatever behavior you want.

Starting from Randal's example, let us assume that now you want
another anonymous class with the same behavior. Instead of repeating
the code that invokes the compiler for it, you could do:

       | myClass myInstance anotherClass |
       myClass := Behavior new. "create anon behavior"
       myClass compile: 'theAnswer ^42'. "add a method for instances"
       myInstance := myClass new. "create an instance"
       Transcript show: myInstance theAnswer; cr. "shows 42"

       anotherClass := Behavior new.
       anotherClass addSelectorSilently: #theAnswer withMethod:
          ((CompiledMethod newFrom: (myClass compiledMethodAt:
#theAnswer))
                                                        methodClass:
anotherClass).
       Transcript show: anotherClass new theAnswer; cr.

If you want, you can change the selector for the method in the new
class to #theOtherAnswer.You can even be fancier and change what the
method #theOtherAnswer returns (e.g. to 43).

       | myClass myInstance anotherClass |
       myClass := Behavior new. "create anon behavior"
       myClass compile: 'theAnswer ^42'. "add a method for instances"
       myInstance := myClass new. "create an instance"
       Transcript show: myInstance theAnswer; cr. "shows 42"

        anotherClass := Behavior new.
       anotherClass addSelectorSilently: #theOtherAnswer withMethod:
         ((CompiledMethod newFrom: (myClass compiledMethodAt:
#theAnswer))
                                                       methodClass:
anotherClass;
                                                       selector:
#theOtherAnswer;
                                                       objectAt: 2
put: 43;
                                                       yourself).
       Transcript show: anotherClass new theOtherAnswer; cr.

Although the above example still uses the compiler to to provide the
prototype method, I hope that by now it is obvious that we can get rid
of it and create the compiled method directly from a sequence of
bytes, instead of copying it from an existing one. This would also
take care of any performance issue caused by invoking the compiler. Of
course, this just moves the problem from source manipulation to
bytecode manipulation, which is not necessarily preferable, but it
shows another way of doing it

oroboros := Class new.
oroboros superclass: Class.
oroboros methodDictionary: MethodDictionery new.
oroboros setFormat: Class format.
oroboros primitiveChangeClassTo: oroboros basicNew
oroboros class = oroboros --> true

To learn more goto http://smallwiki.unibe.ch/adriankuhn/protalk/