1)

T_1[[Den(E)]]ρ ((v1, ..., vk), sk) = Let {(l, sk') = E[[E]]ρ(sk)} ((v1, ..., vk, VD(l)), sk')
B_1[[byReference Ik]] (ρ, (vk, ..., vn), sk) =
    Let {sk' = sk}{ρ' = bind(Ik, vk, ρ)} (ρ', (vk+1, ..., vn), sk')
R_1[[byReference Ik]]ρ ((vk, ..., vn), sk) = Let{sk' = sk} ((vk+1, ..., vn), sk')

2)

Valori Memorizzabili, Denotabili, Esprimibili.

Mutabili (variabili / memorizzabili): ovvero che possono essere modificati, usati principalmente in tutti i linguaggi imperativi
Immutabili (o costanti): ovvero che non possono essere modificati, largamente usati nei linguaggi funzionali, dove anche i valori strutturati sono immutabili (ovvero devono essere ricreati ogni volta che si vogliono modificare)
Denotabili: che possono avere un nome, ovvero espressi dalle definizioni, tutte le volte che viene definita una funzione o procedura con nome, o un nuovo valore mutabile in linguaggi imperativi
Esprimibili: che hanno una rappresentazion sintattica esplicita nel linguaggio, usati nelle definizioni di valori mutabili o immutabili (ad es Java {1, 2, 3, 4, 5}, Caml Costr(val1, val2))

3)
class A extends Object {
    public int x;
    private C y = new C();
    public A () { }
    public A (C u) {
        x = this.y.x + 2;
        y = u;
    }
    public int add(int u) {
        this.x = 2*this.x+u;
    }
}

class B extends A {
    public int x = 0;
    public B (C u) {
        super(u);
    }
    public B () {
        super();
        this.x = 10;
    }
    public int add(int u) {
        this.x = u;
    }
}

class C extends Object {
    public int x = 7;
    C () {}
}

A z = new B(new C())
int w = z.x

4) Le astrazioni totalmente astratte sono astrazioni (funzioni, procedure) che hanno la stessa struttura del programma, e quindi sono unità di programmazione: permettono di definire entità locali, che possono essere anche astrazioni, avere identificatori di entità non locali, passaggio di parametri e valori di ritorno.
Vengono usate per la programmazione basata su decomposizioni, dove si vuole poter decomporre ogni problema in sottoproblemi a qualunque grado di profondità (ovvero anche i sottoproblemi possono essere divisi in sotto-sottoproblemi a loro volta, cosa non possibile per esempio in C)

5) Abbiamo due elementi sintattici per definire record, uno in E per l'allocazione dinamica e uno in D per l'allocazione statica
D ::= ... | Rec T1:I1 T2:I2 ... Tn:In End I | ...
E ::= ... | Talloc (Rec T1:I1 T2:I2 ... Tn:In End) | ...

D[[Rec T1:I1 ... Tn:In End I]]ρ(s) =
    Let {s0 = s}
        {\forall i (li, si) = allocate(Ti, s{i-1})}
        {\forall i γ(Ii) = li}
    (bind(I, ED(γ), ρ), sn)

E[[Talloc (Rec T1:I1 T2:I2 ... Tn:In End)]]ρ(s) =
    Let {s0 = s}
        {\forall i (li, si) = allocate(Ti, s{i-1})}
        {\forall i γ(Ii) = li}
    (EV(γ), sn)