C’era una volta un linguaggio chiamato C, 1 e questo linguaggio aveva qualcosa chiamato struct, e si poteva usare per creare strutture di dati aggregate in modo eterogeneo che avevano membri. La cosa fondamentale da sapere su C è che quando hai una struttura chiamata currentUser, e un membro come id, e scrivi qualcosa come currentUser.id = 42, il complier C ha trasformato questo in istruzioni assembler estremamente veloci. Lo stesso vale per int id = currentUser.id.

Anche importante era che si potevano avere puntatori alle funzioni nelle strutture, quindi si potevano scrivere cose comecurrentUser->setId(42) se si preferiva rendere l’impostazione di unaid una funzione, e questo è stato anche tradotto in assembler veloce.

E infine, la programmazione C ha una cultura molto forte di preferire “estremamente veloce” a solo “veloce”, e quindi se volevi l’attenzione di un programmatore C, dovevi assicurarti di non fare mai qualcosa che è solo veloce quando potevi fare qualcosa che è estremamente veloce. Questa è una generalizzazione, ovviamente. Sono sicuro che se chiediamo in giro, alla fine incontreremo entrambi i programmatori C che preferiscono astrazioni eleganti al codice estremamente veloce.

java e javascript

Poi c’era un linguaggio chiamato Java, ed è stato progettato per essere eseguito in un browser, e di essere portabile su tutti i tipi di hardware e sistemi operativi, e uno dei suoi obiettivi era quello di ottenere C ai programmatori di scrivere codice Java nel browser invece di scrivere C che ha vissuto in un plugin. O meglio, quella era una delle sue strategie, l’obiettivo era che Sun Microsystems rimanesse rilevante in un mondo che Microsoft stava mercificando, ma questo è un altro capitolo del libro di storia.

Quindi le persone simpatiche dietro Java gli hanno dato una sintassi simile a C con le parentesi graffe e la dicotomia istruzione / espressione e la notazione dot. Hanno “oggetti”invece di strutture e gli oggetti hanno molto più successo delle strutture, ma i progettisti di Java hanno fatto una distinzione tra currentUser.id = 42 e currentUser.setId(42), e si sono assicurati che uno fosse estremamente veloce e l’altro fosse solo veloce. O meglio, quello era veloce, e l’altro era solo ok rispetto a C, ma i programmatori C potevano sentirsi come se stessero facendo un pensiero importante al momento di decidere se id dovrebbe essere accessibile direttamente per le prestazioni o indirettamente accessibile per eleganza e flessibilità.

La storia ha dimostrato che questo era il modo giusto per vendere una nuova lingua. La storia ha anche dimostrato che la distinzione effettiva delle prestazioni era irrilevante per quasi tutti. Le prestazioni sono solo per ora, la flessibilità del codice è per sempre.

Beh, si è scoperto che Sun aveva ragione a convincere i programmatori C a usare Java (ha funzionato su di me, ho abbandonato CodeWarrior e Lightspeed C), ma sbagliato sull’uso di Java nei browser. Invece, le persone hanno iniziato a utilizzare un’altra lingua chiamata JavaScript per scrivere codice nei browser e hanno utilizzato Java per scrivere codice sui server.

Ti sorprenderà apprendere che JavaScript è stato progettato anche per far scrivere codice ai programmatori C? E che è andato con la sintassi simile a C con parentesi graffe, la dicotomia istruzione / espressione e la notazione a punti? E sebbene JavaScript abbia una cosa che è un po ‘-sorta come un oggetto Java, e un po ‘ – sorta come un dizionario Smalltalk, ti sorprenderà sapere che JavaScript ha anche una distinzione tra currentUser.id = 42 e currentUser.setId(42)? E che in origine, uno era lento, e l’altro cane-lento, ma i programmatori potrebbero fare importante pensare a quando ottimizzare per le prestazioni e quando dare uno spasso sulla sanità mentale del programmatore?

No, non ti sorprenderà sapere che funziona un po ‘ come C nello stesso modo in cui Java kinda-sort funziona come C, e per esattamente lo stesso motivo. E la ragione non ha più importanza.

il problema con l’accesso diretto

Molto presto dopo che le persone hanno iniziato a lavorare con Java su larga scala, hanno appreso che accedere direttamente alle variabili di istanza era una pessima idea. Compilatori JIT ridotto la differenza di prestazioni tra currentUser.id = 42 e currentUser.setId(42) quasi niente di rilevanza per nessuno, e il codice utilizzando currentUser.id = 42 o int id = currentUser.id era notevolmente inflessibile.

Non c’era modo di decorare tali operazioni con preoccupazioni trasversali come la registrazione o la convalida. Non è possibile ignorare il comportamento di impostazione o ottenere un id in una sottoclasse. (Programmatori Java amano sottoclassi!)

Nel frattempo, anche i programmatori JavaScript stavano scrivendocurrentUser.id = 42, e alla fine anche loro hanno scoperto che questa era una pessima idea. Uno dei catalizzatori per il cambiamento è stato l’arrivo di framework per le applicazioni JavaScript lato client. Diciamo che abbiamo una classe person ridicolmente semplice:

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

E una vista altrettanto ridicola:

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