SICP – cap. 1 – Costruire astrazioni mediante procedure – 1

mms2OK, comincio con il SICP, ne ho parlato qui. Oggi parto con il capitolo 1, è qui: Building Abstractions with Procedures.

Costruire astrazioni mediante procedure

Non è il solito manuale; parte con una citazione di Locke del 1690, validissima per l’informatica –e tutto il resto. Poi si definiscono i processi computazionali come entità astratte che abitano nei computers. Ecco mi trovo già non dico spiazzato ma costretto a usare parole che di solito non uso, chissà 🙄
I processi manipolano entità chiamate dati. Un programma è l’evoluzione di un processo diretto da un sistema di regole; la gente crea programmi per gestire i processi. Poi, non traduco, non voglio responsabilità: [i]n effect, we conjure the spirits of the computer with our spells.

In effetti un processo computazionale e qualcosa di simile a una magia… tuttavia è completamente reale, può fare lavoro intellettuale, rispondere a domande, … Finora non mi ero mai sentito un mago recintante formule magiche, anche se la cosa ha il suo fascino 😀

Imparare a programmare è meno pericoloso che imparare la magia (avete presente vero Terry Pratchett e i maghi dell’Università Invisibile di Ankh-Morpork?) Non posso tradurre tutto, volendo si può leggere là (SICP, non Terry, ma OK anche Terry).

Programmare in Lisp

Abbiamo bisogno di un linguaggio, noi usiamo il Lisp, un formalismo inventato verso la fine degli anni ’50 (ero troppo giovane nel ’58 iniziavo la mia carriera scolastica) su certi tipi di espressioni logiche, chiamate equazioni ricorsive, come modello computazionale. Il linguaggio venne creato da John McCarthy ed è basato sul suo Recursive Functions of Symbolic Expressions and Their Computation by Machine (1960).

Nonostante il formalismo matematico il Lisp è un linguaggio pratico. Seguono alcune note sul suo sviluppo, l’uso, la sua flessibilità, i dialetti, i tentativi di unificazione. Noi useremo Scheme –anzi no, Racket un’evoluzione di Scheme (l’ultima?).

Quel che segue lo salto, un po’ datato (roba anni ’90), oggi viene dato per scontato. Above and beyond these considerations, programming in Lisp is great fun.

Se continuo così sarà lunga; proseguirò in modo molto più sintetico, tanto c’è tutto di là. Passo quindi a:

1.1 Gli elementi della programmazione

[Qui] Un linguaggio di programmazione serve come quadro per organizzare le nostre idee sui processi, cosa che fa con:

  • primitive expressions, which represent the simplest entities the language is concerned with,
  • means of combination, by which compound elements are built from simpler ones, and
  • means of abstraction, by which compound elements can be named and manipulated as units.

1.1.1 Espressioni

Ecco, parto:

s0

Espressioni come queste formate da una lista inclusa tra parentesi sono chiamate combinazioni; Il primo elemento della lista è chiamato operatore, gli altri operandi. Il valore della combinazione è ottenuto applicando la procedura specificata dall’operatore agli argomenti che sono il valore degli operandi.
La notazione prefissa (l’operatore per primo) ha i suoi vantaggi, per esempio

s1

non c’è ambiguità perché l’operatore è sempre il più a sinistra (il primo) e la combinazione è limitata da parentesi.

Altro vantaggio della notazione prefissa è che le combinazioni possono essere annidate, cioè le combinazioni possono avere combinazioni:

s2

naturalmente posso scrivere così:

s3

Even with complex expressions, the interpreter always operates in the same basic cycle: It reads an expression from the terminal, evaluates the expression, and prints the result. This mode of operation is often expressed by saying that the interpreter runs in a read-eval-print loop. Observe in particular that it is not necessary to explicitly instruct the interpreter to print the value of the expression.

1.1.2 Nomi e ambiente

A critical aspect of a programming language is the means it provides for using names to refer to computational objects. We say that the name identifies a variable whose value is the object.

s4

Tutto chiaro, vero? Solo una definizione ancora: It should be clear that the possibility of associating values with symbols and later retrieving them means that the interpreter must maintain some sort of memory that keeps track of the name-object pairs. This memory is called the environment [ambiente] (more precisely the global environment, since we will see later that a computation may involve a number of different environments).

1.1.3 Valutare le combinazioni

One of our goals in this chapter is to isolate issues about thinking procedurally. As a case in point, let us consider that, in evaluating combinations, the interpreter is itself following a procedure.

To evaluate a combination, do the following:

  • 1.  Evaluate the subexpressions of the combination.
  • 2.  Apply the procedure that is the value of the leftmost subexpression (the operator) to the arguments that are the values of the other subexpressions (the operands).

Qui discorso sulla ricorsività, la valutazione è ricorsiva in natura, cioè per ogni passo si richiama la regola stessa.
Non riporto lo spiegone completo di schema che segue, dato per scontato e poi è di là (non lo dirò più ma vale sempre) ma attenzione: Notice that the evaluation rule given above does not handle definitions. For instance, evaluating (define x 3) does not apply define to two arguments, one of which is the value of the symbol x and the other of which is 3, since the purpose of the define is precisely to associate x with a value. (That is, (define x 3) is not a combination.)

Such exceptions to the general evaluation rule are called special forms. define is the only example of a special form that we have seen so far, but we will meet others shortly. Each special form has its own evaluation rule. The various kinds of expressions (each with its associated evaluation rule) constitute the syntax of the programming language. In comparison with most other programming languages, Lisp has a very simple syntax; that is, the evaluation rule for expressions can be described by a simple general rule together with specialized rules for a small number of special forms.

Pausa 😀

:mrgreen:

Annunci
Post a comment or leave a trackback: Trackback URL.

Commenti

  • vinnie  On 27 febbraio 2016 at 19:17

    Fico, anche se non sto provando perché non c’ho voglia di installare tutto l’accrocchio che hai specificato nel post relativo precedente, sto leggendo perché il lisp mi ha sempre affascinato.
    Ma leggendo riassumi tutto l’essenziale o citi solo quello che ti è piaciuto di più? perché se la pazienza mi assiste, sarei curioso di continuare a leggere questa rubrica.
    :{F

    • juhan  On 27 febbraio 2016 at 19:23

      Riassumo (e copio quando il riassunto non basta). Faccio gli eserccizi, ne ho da altre fonti come si vedrà prossimamente.
      Il SICP era fino a poco tempo fa usato come corso introduttivo alla programmazione (non quella à la C++) e per quel che ho visto funzionava. Il guaio è che viene giudicato un modo troppo teorico slegato dal mondo reale per cui si va su Python e (orrore) Java.
      Per quanto mi riguarda credo che la tirerò per le lunghe 😉

  • vinnie  On 27 febbraio 2016 at 20:55

    Ok, grazie juhan, sii scrupoloso e dilungato quanto preferisci che io ti sto leggendo. 😉

Trackbacks

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...

%d blogger hanno fatto clic su Mi Piace per questo: