I think CoffeeScript is mainstream enough at this point that CoffeeScript-based documentation is a fine thing. Especially since, as they say at the top of the page, Batman.js "is written in CoffeeScript and its API is developed with CoffeeScript in mind."
True, but that just basically means that using JS with Batman.js is going to be a pain. In backbone.js you also extend their base classes, but you do it in a js-friendly way (var Widget = Backbone.Model.extend).
Not that there is anything wrong with a CS framework, but they should just say that it's a CS framework. The way CS compiles it's class inheritance to JS is not something I'd want to write raw.
Both simply create an empty object to serve as the prototype (calling new without actually running your constructor), set up the prototype chain correctly, and stash a reference so that calling `super` is easier later on.
If "Child" and "Parent" are constructor functions (class objects), then the basic pattern is this:
var ctor = function(){};
ctor.prototype = Parent.prototype;
Child.prototype = new ctor;
Child.prototype.constructor = Child;
Backbone handles the messy inheritance code for you. Batman.js relies on CS for that, but a JS dev is going to have to write the inheritance code by hand. I posted the JS equivalent of their example in this thread, it's nasty.
* A subclass that inherits the parent's implementation of the constructor function, unless overridden.
* A named function for your class object, without IE scope leaks.
* A way to call super that's as easy as `super()`.
* Inheritance of the parent's own properties (unfortunately via copying).
* ... which enables helpful metaprogramming within class bodies. For example, Batman's own `event` decorator:
use: @event (times) ->
return false unless ...They wrote you a nice library and are giving it away under an MIT license. You don't get to pick the style they use to write the examples. That's like going to a science lecture and walking up to the speaker afterwards to say, "Hey, I think you have some great theories, but you really should lose that Australian accent of yours. Most scientists aren't from Australia, you know."
This is a response to something nobody's saying.
Obviously if they write it they get to choose pretty much everything about it. Nobody is disputing such a thing.
However, if one of the goals in releasing this is to be maximally useful, isn't the fact that raw Javascript is more readily understandable to more people a good thing to point out? Especially since it's highly likely that the team actually has the ability to do normal JS just as easily.
If they disagree with such a goal, though, they can feel free to do whatever they want.
http://jashkenas.github.com/coffee-script/#classes
If they showed JS examples it would instantly turn everyone off. Trust me, you do NOT want to use this with JS.
Or maybe more accurately a speech in modern English to a group of early modern English speakers.
Right... "alternative"... so makes sense to not give examples entirely in it unless your framework is intended solely for Coffeescript users.
(function() {
var Shopify;
var __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
function ctor() { this.constructor = child; }
ctor.prototype = parent.prototype;
child.prototype = new ctor;
child.__super__ = parent.prototype;
return child;
};
Shopify = (function() {
function Shopify() {
Shopify.__super__.constructor.apply(this, arguments);
}
__extends(Shopify, Batman.App);
Shopify.root('products#index');
Shopify.resources('products');
return Shopify;
})();
Shopify.Product = (function() {
function Product() {
Product.__super__.constructor.apply(this, arguments);
}
__extends(Product, Batman.Model);
Product.persist(Batman.RestStorage);
return Product;
})();
Shopify.ProductsController = (function() {
function ProductsController() {
ProductsController.__super__.constructor.apply(this, arguments);
}
__extends(ProductsController, Batman.Model);
ProductsController.prototype.index = function() {
return this.redirect({
action: 'show',
id: 1
});
};
ProductsController.prototype.show = function(params) {
return this.product = Shopify.Product.find(params.id);
};
return ProductsController;
})(); var Shopify = Batman.App.extend()
Shopify.root('products#index')
Shopify.resources('products')
Shopify.Product = Batman.Model.extend()
Shopify.Product.persist(Batman.RestStorage)
// I'm never sure about how much I'm expected to mimic CoffeeScript code
// when using libraries written in CoffeeScript and the source code is
// written in a language I'm not practiced at reading - I've been bitten in
// the past by CoffeeScript-only examples which *assume* you're transpiling
// to JS in your head to insert the implicit return of the result of the
// last expression.
Shopify.ProductsController = Batman.Controller.extend({
index: function() {
return this.redirect({action: 'show', id: 1})
}
, show: function(params) {
return this.product = Shopify.Product.find(params.id)
}
})
var Shopify = Batman.App.extend({
root: 'products#index'
, resources: 'products'
})
[1] https://github.com/documentcloud/backbone/blob/master/backbo...