Q:

Why is a small fixed vocabulary seen as an advantage to RESTful services? 

So, a RESTful service has a fixed set of verbs in its vocabulary.  A RESTful web service takes these from the HTTP methods.  There are some supposed advantages to defining a fixed vocabulary, but I don't really grasp the point.  Maybe someone can explain it. 
Why is a fixed vocabulary as outlined by REST better than dynamically defining a vocabulary for each state?  For example, object oriented programming is a popular paradigm.  RPC is described to define fixed interfaces, but I don't know why people assume that RPC is limited by these contraints.  We could dynamically specify the interface just as a RESTful service dynamically describes its content structure. 
REST is supposed to be advantageous in that it can grow without extending the vocabulary.  RESTful services grow dynamically by adding more resources.  What's so wrong about extending a service by dynamically specifying a per-object vocabulary?  Why don't we just use the methods that are defined on our objects as the vocabulary and have our services describe to the client what these methods are and whether or not they have side effects? 
Essentially I get the feeling that the description of a server side resource structure is equivalent to the definition of a vocabulary, but we are then forced to use the limited vocabulary in which to interact with these resources. 
Does a fixed vocabulary really decouple the concerns of the client from the concerns of the server?  I surely have to be concerned with some configuration of the server, this is normally resource location in RESTful services.  To complain at the use of a dynamic vocabulary seems unfair because we have to dynamically reason how to understand this configuration in some way anyway.  A RESTful service describes the transitions you are able to make by identifying object structure through hypermedia. 
I just don't understand what makes a fixed vocabulary any better than any self-describing dynamic vocabulary, which could easily work very well in an RPC-like service.  Is this just a poor reasoning for the limiting vocabulary of the HTTP protocol? 
Reflection
Just to clarify my thoughts a little better than I have done.  Suppose you are designing any general purpose API, maybe not even web facing.  Would you be happy if someone said you can only use these method names on your objects?  REST isn't restricted to HTTP, but consider the situation where every API you write, web facing or otherwise simply consisted of objects containing GET POST PUT and DELETE methods.  So that object.foo method you wanted to define isn't possible.  You have to define a new object called foo, and call its GET method.  That's essentially how REST works, and it makes me a little uncomfortable to think about it.  You don't have any better generic understanding of what foo does, you were just forced to create a new object for what is essentially a method on a parent object.  Furthermore your API is no less complex, you have just hidden interface complexity by creating more objects.  RESTful web services force us to adopt an interface which may or may not be sufficient in the context of the API we are exposing.  Perhaps there is a good reason for doing this with web facing APIs, but a good reason to not adopt standard interfaces for every object in every general purpose API.  A practical example would be appreciated. 

A:

The "verb" and "noun" terminology is somewhat unfortunate here.  As you already mentioned, you can easily create object for function.  All object oriented languages except Java have that transformation built-in and in Java you end up doing it all the time anyway ending up with lots of objects with single method and often one called "invoke", "execute", "apply" or somesuch (so it's the programming languages where the "verb"/"noun" distinction actually doesn't make sense). 
The "verbs" of REST is more like classifying your methods to getters, setters (deleters; can be considered kind of setters) and other.  And trying to do everything with getters and setters.  The reason for this is:

Easier semantics in face of communication failure, since both getters and setters are idempotent.  Getting the resource twice has no additional effect and nor does setting it to the value it already has. 
Defining some semantics that can be used by possibly caching proxy that does not understand the specific interface.  Getters are cached and setters are known to invalidate the cache. 

HTTP was designed from the beginning with both caches and fault-tolerance in mind, so these two points lead to it's four basic methods:

GET is a getter.  It's assumed not to modify server state and return the same value each time with possibility to specify expiration and revalidation policy. 
PUT and DELETE are the setter and deleter (= setter with nil).  They are not normally used in context of normal web, but make sense for REST. 
POST is a generic "invoke" kitchen sink for which caches can assume nothing. 

REST is a design pattern describing how to use raw HTTP or similar network protocols to implement interface that allows easy handling of failures by simple retrying and works nicely with caching proxies. 
It doesn't correspond easily to regular object-oriented programming API.  I think it is actually a good thing.  The challenges of interfacing over network, which is inherently unreliable and where round-trips are much slower than transferring even moderate amount of data call for different design approach than in-process API, so when it looks different, people don't try to apply invalid experience from the other domain that much (that's the bane of SOAP, XML-RPC and such; it looks like procedure calls, but doesn't work like it and ends up being pain to work with). 

A:

Consider a language where all constructs (such as functions) are objects.  Then the RESTful verbs are simply calling conventions and assignment statements.  For JavaScript you could define a fixed verb syntax like INVOKE for calling a function, DELETE (the same as delete in js) for deleting an object on another object, SET for assigning a value and RETURN for returning a value.  We could use the HTTP verbs to mean the equivalent POST - invoke function, PUT - assign value, GET - return a value, - DELETE - delete an object.  I was caught up in the idea that the HTTP methods were actually describing object methods, actual object interfaces, that I failed to see that it could actually describe much lower level concepts, such as the basic language constructs which are clearly fixed and finite in all sane languages.  HTTP verbs define the object manipulation syntax and the higher level object structure defines the API methods. 
And of course it's helpful for routing/proxying to have a fixed vocabulary to reflect on.