Talk:Prototype-based programming

message: The first sentence of the second paragraph of this article was lifted with only a minor change of punctuation from this Mozilla Developer Network article:
Here's the license on that page, CC A/SA which I believe means that Wikipedia must cite that page.  I'm sure someone will look into this.
Psychlohexane (talk) 21:18, 26 September 2011 (UTC)
thread_title:  Wikipedia license non-compliance? 

message: A few sections of this article confuse the concepts of prototype-based and classless programming.  Prototype-based programming is based on cloning existing prototypical objects.  It is a special case of, but not the same as, classless programming.  A few parts of the article, particularly the ones mentioning JavaScript, get this distinction wrong.  While JavaScript is classless it is not prototype-based since there are no prototypes and no cloning.  The JavaScript language does include a concept of prototypes but in a very different sense from the traditional one. Plesner 19:12, 25 March 2007 (UTC)
thread_title:  A few sections... 

message: What is information hiding?
: Use the wikipedia: Information hiding Wouter Lievens 17:06, 1 May 2005 (UTC)
thread_title:  What is information hiding? 

message: Aside from JavaScript, which PBL's are used outside academia? Wouter Lievens 17:07, 1 May 2005 (UTC)
replies: text: The MOO programming language in MOO.Ryandaum 01:32, 11 January 2006 (UTC)

text: Unlike the relationship between class and instance in class-based object-oriented languages, the relationship between the prototype and its offshoots does not require that the child object have a memory or structural similarity to the prototype beyond this link. As such, the child object can continue to be modified and amended over time without rearranging the structure of its associated prototype as in class-based systems
This is just wrong: not all class-based systems require the structure of the "class" to be changed.  (e.g., in python you can do whatever you want to an instance without changing the class at all) .. this is more a distinction between a statically vs dynamically typed systems.  —Preceding unsigned comment added by 98.212.194.168 (talk) 17:05, 4 June 2010 (UTC)
thread_title:  Uses 

message: Everyone seems to consider Self to be the first prototype-based language, but in actual use among a large number of people, MOO must pre-date it substantially. Note that both languages came out of Xerox PARC, so I'm not suggesting that Ungar and Smith's Self research didn't pre-date MOO, but MOO was in active use as of about 1990, and my sense of Self (hmm) is that it didn't become very "real" until a fair bit later. Anyone with a better sense of the historical details care to clarify this?
MOO did not in fact come out of Xerox PARC.  (I'm an early MOO user, and have heavily edited that article as well as this one).  MOO was created by Stephen White before Pavel Curtis took it over and called it LambdaMOO.  And AFAIK LambdaMOO was never truly an official PARC research project, but instead something that was given hosting by PARC and maintained by Pavel.Ryandaum 01:22, 10 May 2006 (UTC)
thread_title:  History of prototypes 

message: Could someone add an example to clarify the difference between class based and prototype based object creation/cloning?--82.92.191.87 16:44, 29 June 2006 (UTC)
thread_title:  Example of object creation 

message: Can someone please add a source for the following claim:
For example, Lisaac compiler produces code almost as fast as C. Tests have been run with a MPEG-2 codec written in Lissac, copied from a C version. These tests show the Lisaac version is 1.9% slower than the C version with 37% fewer lines of code. --Dzhim 00:14, 7 July 2006 (UTC)
thread_title:  Unsourced statements 

message: The linked prototype-script for ruby does not do what it claims to do and is no complete prototype implementation. When cloning a proto, it does copy the attribute of the source to the destination, but if an attribute links to another object - like an Array - it is not copied. Thus, after copying such protos, they will share the same secondary objects. If you add something to an Array in Proto A, it is also there in Proto B - and the other way around. Therefore, ruby currently has no properly working Prototype-Implementation and therefore should not be listed as supporting Prototypes.
--82.141.50.118 (talk) 02:08, 1 April 2008 (UTC)
thread_title:  Incomplete Prototype implementation reference for ruby 

message: In the section languages E4X is reported as a prototype based language, but it's an extension of ECMAScript and not an ECMAScript derived language. 
Luca.greco (talk) 17:46, 14 January 2009 (UTC)
thread_title:  E4X 

message: Lots of 'weasel wording' and other issues in the critisism section. It appears to have been rewritten to remove all the critisism and instead focus on counteracting arguments. The last paragraph is especially bad - how can a common critisism be that the people making the critisisms are ignorant? It doesn't make any sense. The entire section reads like someone's personal opinion and not fact.
208.118.138.213 (talk)
The whole page suffers from overspecialized points of view. I would not dare to say which language feature prototype-based inheritance, much less "true" prototype-based inheritance.
An issue should come up somewhere, probably in the criticism section: that of the circular reference.( A is prototype of B, and B a prototype of A). Example of this concern ECMA-262.
ECMA-262 4.2.1  gives a normative definition for JavaScript/ECMAScript:
"Every object created by a constructor has an implicit reference (called the object's prototype) to the value of its constructor's prototype property. Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called the prototype chain. When a reference is made to a property in an object, that reference is to the property of that name in the first object in the prototype chain that contains a property of that name."
"Every object created by a constructor" means in fact "Every object": section 11.1.5 defines ObjectLiteral :
" { } is evaluated as follows: Return a new object created as if by the expression new Object() where Object is the standard built-in constructor with that name."
Given this definition, the issue of circular reference appears clearly. It is also a concern of ECMA-262 8.6.2:
"Every Prototype chain must have finite length (that is, starting from any object, recursively accessing the Prototype internal property must eventually lead to a null value)."  — Preceding unsigned comment added by Polbrian (talk • contribs) 10:33, 26 September 2011 (UTC)
thread_title:  Critisism 

message: The OO implementation of LPC is not prototype-based.  Objects are defined by and instantiated from classes, and inheriting classes does not transfer state data to child objects.  —Preceding unsigned comment added by 129.120.93.76 (talk) 16:32, 12 March 2010 (UTC)
thread_title:  Removal of LPC 

message: Unlike the relationship between class and instance in class-based object-oriented languages, the relationship between the prototype and its offshoots does not require that the child object have a memory or structural similarity to the prototype beyond this link.
I'm confused, classed based OO languages do not require any constraints on memory layout. Someone fix this paragraph.  —Preceding unsigned comment added by 99.224.97.6 (talk) 13:16, 16 May 2011 (UTC)
thread_title:  ? 

message: Yes it is true that ActionScript is a prototype-based language, but the version that were prototype-based are so old and rarely used now (I believe only 1.0), that 1.0 should really be added to it. Actionscript 3.0, which has been the de facto standard for years now, is a fully class-based OO language that has more in common with Java or C# than a language like Javascript. This could be a source of confusion. 76.30.21.39 (talk) 20:54, 14 October 2011 (UTC)
replies: text: Does that mean that newer versions don't use prototypes, or have they just been sidelined by classes? —82.36.30.173 (talk) 05:41, 10 November 2012 (UTC)
thread_title: ActionScript

message: The first code-example (in JS) is definitely wrong:
See this section (1):
var bar = {two: "two", three: 3};
And see this section (2):
bar = Object.getPrototypeOf(foo);
1. Section (2) is simply re-assigning `bar`, so, why is Section (1) neccessary?
2. In Section (2), `Object.getPrototypeOf(foo)` returns `Object.prototype`, which have no such property call "one", "two" or "three"
It makes nonsence, and wrong, please delete it.  — Preceding unsigned comment added by Khải (talk • contribs) 12:49, 7 November 2015 (UTC)
thread_title:  Wrong code-example 

message: In the intro section, there's the "Let's use the idea of "fruit" as one example..." paragraph. The point of view it's speaking from and overall wording and tone feels different to the rest of the article. I think it should be rewritten, reworded, or otherwise edited in some way. Jchen57 (talk) 00:30, 13 June 2017 (UTC)
replies: text: I've tried to reword it to get rid of the "Let's use...", but I'm still unsure if that kind of paragraph is needed in the head. I'd think about moving it to under "features", or even getting rid of it entirely. A picture of a dead fish (talk) 03:31, 26 July 2017 (UTC)
thread_title:  Fruit example in intro 

message: There was no justification for calling concatenative prototyping "pure prototyping".  Kevo, a relative newcomer (and a dead language, it seems), seems to be the only language to make this the default implementation of prototyping (as opposed to an option that can be implemented by the developer in any prototyping language).  This page (and a few stackoverflow pages that reference it) seems to be the only place where the term is used with this meaning. Itsbruce (talk) 11:50, 24 June 2018 (UTC)
thread_title:  Removed contentious description of contatenation as "pure prototyping"