I think you're wrong about the constructor's "prototype" property

Hey Addy, I've been reading your Javascript design patterns online, and I think it's a marvelous book. I respect you a lot, so don't think that I'm attacking you ( or your knowledge of Javascript ) in any way, shape or form. In fact, I really do admire your knowledge.

In the "Constructors with Prototypes" subsection you say this:

> Functions, like almost all objects in JavaScript, contain a "prototype" object. When we call a JavaScript constructor to create an object, all the properties of the constructor's prototype are then made available to the new object.

I don't think that this is right. I think that the "prototype" property actually points to the prototype object of all objects instantiated by the constructor, but not the constructor's prototype itself.

I did a test today in Developer Tools, and this really seems to be the case.

Take this for an example; we have a constructor function ( I'm going to use your example if you don't mind ):

``` javascript
function Car( model, year, miles ) {

this.model = model;
this.year = year;
this.miles = miles;

}
```

Now, if I check the prototype of this function in Chrome Developer Tools,

``` javascript
Car.__proto__
```

... I will get this:

``` javascript
function Empty() {}
```

, which is the uppermost prototype of all functions. Now, I can instantiate the Car 'class':

``` javascript
var myFord = new Car( 'My Ford', 2015, 0 );
```

, and then see its prototype:

``` javascript
myFord.__proto__
```

...then I get this:

``` javascript
Car{}
```

So, I don't think that the function's "prototype" property actually points to it's own prototype; rather, it point's to the prototype of all objects that were instantiated by it.