Egyszer volt, hol nem volt,volt egy nyelv úgynevezett C, 1 és ez a nyelv volt valami úgynevezett struct, és lehetett használni, hogy heterogén aggregált adatstruktúrák voltak tagjai. A legfontosabb dolog, amit tudni kell a C-ről, hogy ha van egy currentUser nevű struktúrád, és egy olyan tagod, mint id, és valami ilyesmit írsz currentUser.id = 42, A C complier ezt rendkívül gyors assembler utasításokká változtatta. Ugyanez a int id = currentUser.idesetében.

az is fontos volt, hogy a structs függvényekre mutató mutatókkal rendelkezzünk, így olyan dolgokat írhatunk, mint a currentUser->setId(42), ha a id beállítást választottuk, és ezt lefordítottuk fast assembler-re is.

és végül, a C programozás nagyon erős kultúrával rendelkezik, amely inkább a “rendkívül gyors”, mint a “gyors”, és így ha egy C programozó figyelmét akartad, meg kellett győződnöd arról, hogy soha nem csinálsz valamit, ami csak gyors, amikor megtehetsz valamit, ami rendkívül gyors. Ez természetesen általánosítás. Biztos vagyok benne, hogy ha körbekérdezünk, végül találkozunk mindkét C programozóval, akik az elegáns absztrakciókat részesítik előnyben a rendkívül gyors kód helyett.

java és javascript

akkor volt egy Java nevű nyelv, amelyet úgy terveztek, hogy böngészőkben fusson, és hordozható legyen mindenféle hardveren és operációs rendszeren, és az egyik célja az volt, hogy a C programozókat Java kód írására késztesse a böngészőben, ahelyett, hogy C-t írna, amely egy pluginben élt. Vagy inkább ez volt az egyik stratégiája, a cél az volt, hogy a Sun Microsystems releváns maradjon egy olyan világban, amelyet a Microsoft árucikké tett, de ez a történelemkönyv újabb fejezete.

tehát a Java mögött álló kedves emberek C-szerű szintaxist adtak neki a zárójelekkel, az utasítás/kifejezés dichotómiával és a pont jelöléssel. Structok helyett “objektumok” vannak, és az objektumok sokkal többet csinálnak, mint a structok, de a Java tervezői különbséget tettek a currentUser.id = 42 és a currentUser.setId(42) között, és megbizonyosodtak arról, hogy az egyik rendkívül gyors, a másik pedig csak gyors. Vagy inkább, hogy az egyik gyors volt, a másik pedig csak rendben volt a C-hez képest, de a C programozók úgy érezhették, hogy fontos gondolkodást végeznek, amikor eldöntötték, hogy a id közvetlenül a teljesítmény érdekében, vagy közvetetten az elegancia és a rugalmasság érdekében kell-e elérni.

a történelem azt mutatja, hogy ez volt a helyes módja egy új nyelv eladásának. A történelem azt is megmutatta, hogy a tényleges teljesítménykülönbség szinte mindenki számára irreleváns volt. A teljesítmény csak egyelőre, a kód rugalmassága örökre szól.

nos, kiderült, hogy a Sunnak igaza volt abban, hogy a C programozókat a Java használatára késztette (rajtam működött, a Codewarriort és a Lightspeed C-t elhagytam), de tévedett a Java böngészőkben történő használatával kapcsolatban. Ehelyett az emberek elkezdtek egy másik nyelvet, a JavaScript – et használni, hogy kódot írjanak a böngészőkben, a Java-t pedig a szervereken.

meg fog lepődni, ha megtudja, hogy a JavaScript-et arra is tervezték, hogy a C programozók kódot írjanak? És hogy a C-szerű szintaxis, a göndör zárójelekkel, az állítás/kifejezés dichotómiával és a pont jelöléssel ment? És bár a JavaScriptnek van valamije, ami olyan, mint egy Java objektum, és olyan, mint egy Smalltalk szótár, meglepő lesz, ha megtudja, hogy a JavaScript is különbséget tesz a currentUser.id = 42 és a currentUser.setId(42)között? És ez eredetileg az egyik lassú volt, a másik kutya-lassú, de a programozók fontos gondolkodást tudtak tenni arról, hogy mikor optimalizálják a teljesítményt, és mikor kell huhogni a programozó józanságáról?

nem, nem lep meg, ha megtudod, hogy ugyanúgy működik, mint a C, ugyanúgy, mint a Java kinda-sort, mint a C, és pontosan ugyanezen okból. És az OK már nem számít.

a közvetlen hozzáférés problémája

nagyon hamar, miután az emberek elkezdtek dolgozni a Java-val, megtudták, hogy a példányváltozók közvetlen elérése szörnyű ötlet volt. A JIT fordítói a currentUser.id = 42 és a currentUser.setId(42) közötti teljesítménykülönbséget szinte senki számára nem relevánsra szűkítették, és a currentUser.id = 42 vagy int id = currentUser.id kód használata rendkívül rugalmatlan volt.

az ilyen műveleteket nem lehetett olyan átfogó aggályokkal díszíteni, mint a naplózás vagy az érvényesítés. Nem tudta felülbírálni a id beállításának vagy megszerzésének viselkedését egy alosztályban. (A Java programozók szeretik az alosztályokat!)

közben a JavaScript programozók is írtak currentUser.id = 42, és végül ők is rájöttek, hogy ez egy szörnyű ötlet. A változás egyik katalizátora az ügyféloldali JavaScript alkalmazások keretrendszereinek érkezése volt. Tegyük fel, hogy van egy nevetségesen egyszerű személy osztály:

const currentUser = new Person('Reginald', 'Braithwaite');const currentUserView = new PersonView(currentUser);currentUserView.redraw();currentUser.first = 'Ragnvald';currentUserView.redraw();

class Model { constructor () { this.listeners = new Set(); } get (property) { this.notifyAll('get', property, this); return this; } set (property, value) { this.notifyAll('set', property, value); return this = value; } addListener (listener) { this.listeners.add(listener); } deleteListener (listener) { this.listeners.delete(listener); } notifyAll (message, ...args) { for (let listener of this.listeners) { listener.notify(this, message, ...args); } }}class Person extends Model { constructor (first, last) { super(); this.set('first', first); this.set('last', last); } fullName () { return `${this.get('first')} ${this.get('last')}`; }};class View { constructor (model) { this.model = model; model.addListener(this); }}class PersonView extends View { // ... notify(notifier, method, ...args) { if (notifier === this.model && method === 'set') this.redraw(); } redraw () { document .querySelector(`person-${this.model.id}`) .text(this.model.fullName()) }}

const currentUser = new Person('Reginald', 'Braithwaite');const currentUserView = new PersonView(currentUser);currentUser.set('first', 'Ragnvald');

const after = (behaviour, ...methodNames) => (clazz) => { for (let methodName of methodNames) { const method = clazz.prototype; Object.defineProperty(clazz.prototype, methodName, { value: function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }, writable: true }); } return clazz; }function LogSetter (model, property, value) { console.log(`Setting ${property} of ${model.fullName()} to ${value}`);}@after(LogSetter, 'set')class Person extends Model { constructor (first, last) { super(); this.set('first', first); this.set('last', last); } fullName () { return `${this.get('first')} ${this.get('last')}`; }};

class Model { constructor () { this.listeners = new Set(); } addListener (listener) { this.listeners.add(listener); } deleteListener (listener) { this.listeners.delete(listener); } notifyAll (message, ...args) { for (let listener of this.listeners) { listener.notify(this, message, ...args); } }}const _first = Symbol('first'), _last = Symbol('last');class Person extends Model { constructor (first, last) { super(); this.first = first; this.last = last; } get first () { this.notifyAll('get', 'first', this); return this; } set first (value) { this.notifyAll('set', 'first', value); return this = value; } get last () { this.notifyAll('get', 'last', this); return this; } set last (value) { this.notifyAll('set', 'last', value); return this = value; } fullName () { return `${this.first} ${this.last}`; }};

const currentUser = new Person('Reginald', 'Braithwaite');const currentUserView = new PersonView(currentUser);currentUser.first = 'Ragnvald';

function getPropertyDescriptor (obj, property) { if (obj == null) return null; const descriptor = Object.getOwnPropertyDescriptor(obj, property); if (obj.hasOwnProperty(property)) return Object.getOwnPropertyDescriptor(obj, property); else return getPropertyDescriptor(Object.getPrototypeOf(obj), property);};const after = (behaviour, ...methodNames) => (clazz) => { for (let methodNameExpr of methodNames) { const = methodNameExpr.match(/^(?:(get|set) )(.+)$/); const descriptor = getPropertyDescriptor(clazz.prototype, methodName); if (accessor == null) { const method = clazz.prototype; descriptor.value = function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }; descriptor.writable = true; } else if (accessor === "get") { const method = descriptor.get; descriptor.get = function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }; descriptor.configurable = true; } else if (accessor === "set") { const method = descriptor.set; descriptor.set = function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }; descriptor.configurable = true; } Object.defineProperty(clazz.prototype, methodName, descriptor); } return clazz; }

const notify = (name) => function (...args) { this.notifyAll(name, ...args); };@after(notify('set'), 'set first', 'set last')@after(notify('get'), 'get first', 'get last')class Person extends Model { constructor (first, last) { super(); this.first = first; this.last = last; } get first () { return this; } set first (value) { return this = value; } get last () { return this; } set last (value) { return this = value; } fullName () { return `${this.first} ${this.last}`; }};

const Notifier = mixin({ init () { this.listeners = new Set(); }, addListener (listener) { this.listeners.add(listener); }, deleteListener (listener) { this.listeners.delete(listener); }, notifyAll (message, ...args) { for (let listener of this.listeners) { listener.notify(this, message, ...args); } }}, { notify (name) { return function (...args) { this.notifyAll(name, ...args); } }});

@Notifier@after(Notifier.notify('set'), 'set first', 'set last')@after(Notifier.notify('get'), 'get first', 'get last')class Person { constructor (first, last) { this.init(); this.first = first; this.last = last; } get first () { return this; } set first (value) { return this = value; } get last () { return this; } set last (value) { return this = value; } fullName () { return `${this.first} ${this.last}`; }};

get first () { return this;}set first (value) { return this = value;}get last () { return this;}set last (value) { return this = value;}

function attrAccessor (...propertyNames) { return function (clazzOrObject) { const target = clazzOrObject.prototype || clazzOrObject; for (let propertyName of propertyNames) { Object.defineProperty(target, propertyName, { get: function () { if (this.attributes) return this.attributes; }, set: function (value) { if (this.attributes == undefined) this.attributes = new Map(); return this.attributes = value; }, configurable: true, enumerable: true }) } return clazzOrObject; }}