Except Self uses.

Wiscombe: Profsimm: why would you want to bind all of the methods to a single object anyway?

Sages: Profsimm: extending instances is what JS’s OO model is all about. There are only instances in this language

Marth: Dekok: so I don’t have to bind them every time I p*** them somewhere

Lasik: Dekok: you’re still in the 90s

Burlage: JS’s OO model is accidentally this way.

Carey: Profsimm: I’d recommend stopping with the personal attacks

Mauger: It wasn’t a good idea and it still isn’t.

Redell: Is theresome function that returns the parent form of the current button that got clicked ? so i use it in the onclick event

Dentel: Profsimm: and no, JS’s OO model is fundamentally based on objects inheriting directly from objects. It has always been like that, it will always be like that.

Aeschliman: Profsimm: also, the whole committee designing JS disagrees with you about it being a “bad idea”

Daponte: I mean so i use the form in an ajax code and update the DB

Simi: But sure, you’re free to do your own thing. If you want “cl***es,” just implement that model on top of prototypes.

Korslund: Dekok: looking at ES6 cl***es, that’s debatable. They’re paying lip service to a certain JS creator, but really the writing is on the wall

Pefferkorn: You *do* take the performance hit from that, and your objects won’t really be interacting with the rest of the language.

Amaral: Profsimm: ES6 cl***es are not cl***ical OO cl***es…

Wakley: Profsimm: JavaScript does not have cl***-based OO Java, C#, Python, etc., instead it uses prototype-based OO, where objects dictate their own behaviour methods, and inherit directly from other objects by cloning. See http://raganwald.com/2015/05/11/javascript-cl***es.html for details.

Schollmeier: They’re *fundamentally different* OO models.

Sammer: Dekok: the difference is verbal more than mechanical, so yes they are.

Laubhan: You can implement one on top of the other.

Greenly: EvalInt === 0 ? return true : return false;

Belliveau: Profsimm: it’s a semantic difference.

Reiniger: Profsimm: prototype-based OO is, semantically, very different from cl***-based OO.

Guszak: Dekok: in fact, save yourself the time. I know the argument, and I don’t buy it.

Salowitz: Profsimm: in a cl***-based OO language, you have cl***es, which are the *SOLE THING* that determine the layout of objects. Objects are intrinsically attached to a cl***. Objects might change cl***es during runtime as they do in Smalltalk. In prototype-based OO languages, each obect defines its own layout.

Levreau: Profsimm: if you want to ignore OO literature, sure, go ahead.

Karin: Profsimm: you’re free to read that same definition from Self’s academic papers as well: http://bibliography.selflanguage.org/self-power.html

Posch: Dekok: each object defines its layout. based on the prototype. Each object has a layout. based on the cl***.

Thornes: Anything I should change in my code for “best practice”? http://i.imgur.com/M5PS4bq.png

Vergeer: Dekok: ellipsis! I’m convinced.

Zielinski: Profsimm: go read Self’s paper instead of twisting my words, why don’t you?

Eschenburg: Dekok: I don’t care about Self.

Wernert: Frogdr: that’s not recursive

Roznowski: Profsimm: good. Then don’t criticise JS’s OO model based on wrong definitions of the term “prototype-based OO.”

Mulaney: Who’s using gulp? What’s wrong here? https://gist.github.com/anonymous/48f88a2c6a6ef2dad72c

Palmiter: Dekok: Self is not JS either.

Mazzone: Profsimm: you’re free to think whatever you want about the model being good or bad, just don’t spread misinformation.

Naftel: Dekok: and if I cared, I’d link you to materials discussing it.

Burkard: Profsimm: it isn’t. But the OO model is the same thing.

Mchargue: Except Self uses multi-delegation, whereas JS only has single-delegation