Coding convention when using differential inheritance Ever since reading Crockford's "Good Parts" and Johansen's TDD book, I have wanted to use more of the differential inheritance pattern in my coding at work (as in avoiding new by using Object.create()), but I find that I am having a hard time argumenting for the clearness of the code when trying to make "types" that can be used for object creation. Most of my co-workers are "classically" inclined.

I guess this question somehow boils down to these points


downcasing/UpperCasing (i.e. "car" vs "Car")
prefixing the base instances (i.e "prototypeCar"). This practice is for instance seen in the code of the author of Fluent Javascript 
init() methods VS factory methods. 

// init style
car.init = function(brand) {
    this.brand = brand; 
}
myCar = Object.create(car).init("Nissan");

// versus

// factory method
function createCar(brand) { 
    var o = Object.create(car);
    o.brand = brand;
    return o;
}

// alternative factory method
function createCar(brand) { 
    var o = Object.create(car, { brand : brand } )
    return o;
}

myCar = createCar("nissan")



My problem with having lower cased car types is that for someone glancing over parts of the code, they might think that car is an instance of some kind of 'class' Car, and get confused when I suddenly start creating new instances from it. In my opinion, the notion of using a prefix, such as "prototype", seems to more clearly state my intentions with the instance. So do saying Car, but that implies that it should be used together with new, so one should perhaps refrain from that ... (?)
I see a conceptual issue with this approach: it is nice to inherit from objects, but these entities are not the "real" object. In other words, there is no much sense in using them outside of initialization code. If you need new [Cc]ar then it will not be wise to take any car that is nearby and just modify it and enjoy numerous side effects - you probably need some "etalon" of cars. The Car.

To be honest, I frequently have an intention to use only factory methods in JavaScript and not use the operator new at all. But then I look on how many should I rewrite for that and give up because I do not see the real benefits from this approach - it is not a big task to rename the constructor Something to factory method createSomething and replace it within the code, but what is next?