Er was eens een taal genaamd C, 1 en deze taal had iets genaamd een struct, en je kon het gebruiken om heterogene geaggregeerde datastructuren te maken met leden. Het belangrijkste dat je moet weten over C is dat wanneer je een struct hebt genaamd currentUser, en een lid als id, en je iets schrijft als currentUser.id = 42, de C complier dit veranderde in extreem snelle assembler instructies. Hetzelfde voor int id = currentUser.id.

ook van belang was dat u pointers naar functies in structs kon hebben, zodat u dingen als currentUser->setId(42) kon schrijven als u er de voorkeur aan gaf om het instellen van een id een functie te maken, en dit werd ook vertaald in fast assembler.

en tot slot, C programmeren heeft een zeer sterke cultuur van de voorkeur “extreem snel” dan gewoon “snel,” en dus als je de aandacht van een C programmeur wilde, moest je ervoor zorgen dat je nooit iets doet dat gewoon snel is als je iets kon doen dat extreem snel is. Dit is een generalisatie, natuurlijk. Ik weet zeker dat als we rondvragen, we uiteindelijk beide C-programmeurs zullen ontmoeten die elegante abstracties verkiezen boven extreem snelle code.

java en javascript

toen was er een taal genaamd Java, en het was ontworpen om te draaien in browsers, en draagbaar zijn over allerlei hardware en besturingssystemen, en een van de doelen was om C programmeurs Java-code te laten schrijven in de browser in plaats van C te schrijven die in een plugin leefde. Of beter gezegd, dat was een van de strategieën, het doel was voor Sun Microsystems om relevant te blijven in een wereld die Microsoft commoditizing, maar dat is een ander hoofdstuk van de geschiedenis boek.

dus de aardige mensen achter Java gaven het een C-achtige syntaxis met de accolades en de statement / expression dichotomie en de dot notatie. Ze hebben “objecten” in plaats van struct ‘s, en objecten hebben veel meer gaande dan struct’ s, maar de ontwerpers van Java maakten een onderscheid tussen currentUser.id = 42 en currentUser.setId(42), en zorgden ervoor dat de ene extreem snel was en de andere gewoon snel. Of beter gezegd, die ene was snel, en de andere was gewoon ok in vergelijking met C, maar C-programmeurs konden het gevoel hebben dat ze belangrijke gedachten deden bij de beslissing of id direct toegankelijk moest worden voor prestaties of indirect toegankelijk voor elegantie en flexibiliteit.

De geschiedenis heeft aangetoond dat dit de juiste manier was om een nieuwe taal te verkopen. De geschiedenis heeft ook aangetoond dat het feitelijke prestatieverschil voor bijna iedereen irrelevant was. Performance is alleen voor nu, Code flexibiliteit is voor altijd.

wel, het bleek dat Sun gelijk had over het krijgen van C programmeurs om Java te gebruiken (het werkte bij mij, ik dumpte CodeWarrior en Lightspeed C), maar verkeerd over het gebruik van Java in browsers. In plaats daarvan, mensen begonnen met behulp van een andere taal genaamd JavaScript om code te schrijven in browsers, en gebruikte Java om code te schrijven op servers.

zal het u verbazen dat JavaScript ook is ontworpen om C-programmeurs code te laten schrijven? En dat het ging met de C-achtige syntaxis met krullende beugels, de uitspraak / uitdrukking dichotomie, en dot notatie? En hoewel JavaScript een ding heeft dat een beetje lijkt op een Java object, en een beetje op een Smalltalk woordenboek, zal het je verbazen dat JavaScript ook een onderscheid maakt tussen currentUser.id = 42 en currentUser.setId(42)? Oorspronkelijk was de ene traag, en de andere hond-traag, maar programmeurs konden belangrijk nadenken over wanneer te optimaliseren voor prestaties en wanneer een giller geven over de gezond verstand van programmeurs?

Nee, Het zal je niet verbazen dat het een beetje als C werkt op dezelfde manier als Java kinda-sort werkt als C, en om precies dezelfde reden. En de reden doet er niet meer toe.

het probleem met directe toegang

zeer snel nadat mensen begonnen te werken met Java op schaal, leerden ze dat het direct benaderen van instantievariabelen een verschrikkelijk idee was. JIT-compilers versmalden het prestatieverschil tussen currentUser.id = 42 en currentUser.setId(42) tot bijna niets dat voor iedereen relevant is, en code met currentUser.id = 42 of int id = currentUser.id was opmerkelijk inflexibel.

Er was geen manier om dergelijke bewerkingen te verfraaien met horizontale problemen zoals logging of validatie. U kon het gedrag van het instellen of verkrijgen van een id in een subklasse niet overschrijven. (Java programmeurs houden van subklassen!)

ondertussen schreven JavaScript-programmeurs ook currentUser.id = 42, en uiteindelijk ontdekten ook zij dat dit een verschrikkelijk idee was. Een van de katalysatoren voor verandering was de komst van frameworks voor client-side JavaScript-toepassingen. Laten we zeggen dat we een belachelijk eenvoudige persoonsklasse hebben:

class Person { constructor (first, last) { this.first = first; this.last = last; } fullName () { return `${this.first} ${this.last}`; }};

class PersonView { constructor (person) { this.model = person; } // ... redraw () { document .querySelector(`person-${person.id}`) .text(person.fullName()) }}

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; }}

@Notifier@attrAccessor('first', 'last')@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; } fullName () { return `${this.first} ${this.last}`; }};