Forum libero

Scritto da: Rick Sanchez
> https://raconteurreport.blogspot.com/2018/05/solo-...

Non era male il film, ma mi è piaciuto sicuramente di più il primo spin-off: Rogue One.

Tra quelli fatti dalla disney, Rogue On è sicuramente il migliore e può competere con i classici.

https://raconteurreport.blogspot.com/2018/05/solo-...

Scritto da:
> Scritto da: Rick Sanchez
> >
>
> Quello che hanno ottenuto finora non sembra così problematico, perché non hanno ottenuto niente che vada contro la libertà e la democrazia.
>
> Se si continua come ora credo che non ci saranno problemi.

Non è che se una cosa è democratica non è problematica.

Scritto da: Rick Sanchez
>

Quello che hanno ottenuto finora non sembra così problematico, perché non hanno ottenuto niente che vada contro la libertà e la democrazia.

Se si continua come ora credo che non ci saranno problemi.

Scritto da:
> Quelli su Amazon indicati da Wakko da 250 GB circa costano sui 50 euro.
>
> Ne esisteranno modelli IDE di capienza minore (e prezzo proporzionalmente ridotto) da montare su un vecchio PC del 2000?

Non so, penso che gli SSD abbiano solo interfaccia SATA. Non avrebbe senso crearne con interfaccia PATA perché il disco sarebbe più veloce dell'interfaccia (e anche perché oramai da anni non si producono più computer con interfaccia PATA).

Comunque dovrebbero esistere adattatori SATA-PATA.

**Modificato dall'autore il 02.06.2018 10:13**

Scritto da:
> > Esercizi completati. Domande?
>
> Console.WriteLine(string.Format("Il long di default è {0}", defaultLong));
>
> Cos'è {0} e che ruolo ha?
> Ovvero come funziona string.Format()?

La forma più arcaica di scrivere la stessa cosa sarebbe

Console.WriteLine("Il long di default è " + defaultLong);

Mettendo il + fra due numeri restituisce la somma, mentre messo tra due stringhe ("frasi") restisuice una stringa che è il risultato della concatenazione tra le due stringhe.

In questo caso, si tratta di una concatenazione tra una stringa e un numero: il numero viene prima di tutto convertito in stringa (casting implicito) e poi concetanato con l'altra stringa.

string.Format è una "funzione" (sarebbe più corretto chiamarla "metodo" nell'ambito della programmazione a oggetti) che offre un un modo più "pulito" per fare concatenazioni.

Alla funzione string.Format si passano delle stringhe contenenti dei parametri. I parametri sono numerati in maniera incrementale partendo da 0 e si presentano come segue:
- {0} primp parametro
- {1} secondo parametro
- {2} terzo parametro

e così via


Quindi, nel nostro caso, la stringa presa in è: "Il long di default è {0}". In questa stringa c'è un solo parametro, quindi il parametro {0}.

I parametri (che vanno a sostituire i "segnaposto") vengono specificati uno per uno dopo la stringa.

Facciamo un esempio più complesso.

String output = "La soma tra 2 e 3 è 5, la moltiplicazione è 6, la potenza è 8";

Si può riscrivere in questa maniera

String output = "La soma tra " + 2 + "e " + 3 "è " + 5 + ", la moltiplicazione è" + 6 + ", la potenza è 8";

Non è molto bello da leggere, vero?

Più elegante invece

String output = string.Format("La soma tra {0} e {1} è {2}, la moltiplicazione è {3}, la potenza è {4}", 2, 3, 5, 6, 8);

Ovviamente però questo tipo di codice non è molto utile, perché i valori nell'esempio sono prestabiliti, mentre un programma nel mondo reale solitamente utilizza vaolori variabili... e quindi le variabili.

String output = string.Format("La soma tra {0} e {1} è {2}, la moltiplicazione è {3}, la potenza è {4}", primoNumero, secondoNumero, somma, moltiplicazione, potenza);

Le variabili sono già state dichiarate e calcolate, non faccio altro che usarle.

A questo punto posso passare la variabile "output" a Console.WriteLine.

Console.WriteLine(output);

Oppure, più semplicemente

Console.WriteLine(string.Format("La soma tra {0} e {1} è {2}, la moltiplicazione è {3}, la potenza è {4}", primoNumero, secondoNumero, somma, moltiplicazione, potenza));

Capito?

> Esercizi completati. Domande?

Console.WriteLine(string.Format("Il long di default è {0}", defaultLong));

Cos'è {0} e che ruolo ha?
Ovvero come funziona string.Format()?

Scritto da:
> cosa fai al poligono? spari con pistola o fucile?

Scritto da:
> Scritto da:
> > Scritto da: Rick Sanchez
> > > ...non sto granché bene e coccolino era in gita... sto molto meglio quando lui è qui con me, mi piacerebbe portarlo un po' in giro, chessò... a vedere qualche bel posto di interesse scientifico o naturalistico (la Grotta Gigante di Trieste per esempio), o anche al poligono... ma devo accontentarmi, non posso esagerare... devo ricordarmi di dirgli quanto gli voglio bene anche se penso lo sappia già, spero passeremo un bel po' di tempo assieme questa estate.
> >
> > Ma non ha dei genitori la scorreggia? Lo porti al poligono per cosa, la pratica per il maneggio non la fate già in privato?
>
> Gli starà insegnando a sparare ai ladri di biciclette, in aggiunta a qualche insegnamento teorico su quanto siano femminucce i maschi che non hanno idee di destra, che sarebbero in combutta con le femmine e le femministe per distruggere l'occidente.

Un futuro ordine ricchion insomma.

Posto le soluzioni

Scritto da: Mattia
> 1) Spiega che cosa è .NET. Elenca il tipo di applicazioni che si possono realizzare con .NET. Quali sono i due principali linguaggi di programmazione di .NET?

.NET è un framework per lo sviluppo di applicazioni in ambienti windows.
È possibile con esso realizzare diversi tipi di applicazione: applicazioni console, applicazioni GUI per windows, applicazioni web, applicazioni mobile (con Xamarin), programmi destinati a far funzionare "internet of things" e applicazioni HMI (interfaccia uomo-macchina).

I due linguaggi di programmazione principali di .NET sono C# e Visual Basic, ma ce ne sonio anche diversi altri:

- F#: un linguaggio multiparadigma che consente, oltre alla programmazione ad oggetti come C#, anche la programmazione funzionale

- J#: un linguaggio che assomiglia a java, fatto per i programmatori java che vogliono sviluppare con .NET

- C++/CLI: una versione managed del C++ (in Visual Studio è comunque possibile anche programmare con il vero C++)


> 2) C# rientra nella categoria dei linguaggi managed, a differenza di altri linguaggi (come ad esempio il C) che è unmanaged. Qual'è la differenza tra un linguaggio managed e un linguaggio unmanaged?

Un linguaggio managed gira su una macchina virtuale, a differenza dei linguaggi unmanaged (come il C).

C# viene compilato in un linguaggio chiamato CLI, ovvero un linguaggio di più basso livello rispetto a C# che viene eseguito dal CLR (una macchina virtuale).

Un linguaggio unmanaged con il C invece viene compilato in linguaggio macchina, che ovviamente viene eseguito dalla macchina fisica e non da una macchina virtuale.


> Quali sono i vantaggi di un linguaggio managed?

In un linguaggio managed si può delegare alla macchina virtuale la gestione della memoria.

Nel C bisogna sempre ricordarsi di ripulire tutte le risorse allocate nell'heap. Questo richiede la scrittura di diverse righe di codice, in particolare è necessario dichiarare un distruttore in ogni classe che ha allocato risorse nell'heap.

Se non si ripulisce adeguatamente l'heap, ci possono essere dei memory leak (perdite di memoria) che si possono tradurre in un progressivo sovraccarico della memoria, oppure in situazioni in cui una risorsa del sistema operativo resta parmententemente aperta: ad esempio "file già in uso", "porta già in uso" e cose del genere.

In in linguaggio managed come C# la memoria è autogestita: questo significa, prima di tutto, che non ci si deve preoccupare di allocare risorse nell'heap piuttosto che nello stack, perché queste cose se le gestisce da solo il CLR.

Il più grosso vantaggio però risiede nel garbage collector, ovvero "il ripulitore automatico della memoria": il garbage collector capisce quando un oggetto non serve più: non serve più quando ogni referenza ad esso cessa di esistere, o per meglio dire non è più necessaria.

> Esistono risorse unmanaged in C#?

Si. Sono generalmente non gestite le risorse che non appartengono a .NET (come gli oggetti) ma al sistema operativo sottostante (file, connessioni,...).

Il pattern di C# per ripulire la memoria però è diverso da quello del C: una classe che utilizza risorse unmanaged, deve implementare un'interfaccia che si chiama IDisposable.
Se si utilizassero i distruttori come nel C sarebbe poco utile, perché il distruttore verrebbe chiamato dal garbage collector quando lo decide lui, mentre grazie all'interfaccia IDIsposable l'utilizzatore della classe acquisisce il controllo sulla gestione della memoria e la può ripulire non appena le classe non gli serve più.


> 3) Javascript è un linguaggio interpretato. C e C# sono linguaggi compilati. Il C viene compilato in linguaggio macchina, mentre C# viene compilato in un linguaggio che viene chiamato CIL (Common Intermediate Language).
> Spiega che differenza c'è tra un linguaggio interpretato e uno compilato e spiega la differenza tra il linguaggio macchina e il CIL. Qual'è il vantaggio di un linguaggio che non viene compilato in linguaggio macchina?

Un linguaggio interpretato viene eseguito da un programma, che lo legge nella sua forma originale.

Un linguaggio compilato invece viene prima tradotto in un linguaggio di più basso livello e poi viene eseguito.

Il C è un linguaggio puramente compilato, in quanto la sua compilazione produce file eseguibili contenenti linguaggio macchina.

C# invece è un miscuglio tra un linguaggio compilato e uno interpretato: viene compilato in un linguaggio di più basso livello, ma poi questo deve essere interpretato da un programma (il CLR, appunto) non essendo chiaramente eseguibile dalla macchina.

Il vantaggio di un linguaggio non puramente compilato (o interpretato al 100%) risiede, oltre che nella risposta alla precedente domanda (linguaggio managed vs linguaggio unmanaged), anche nel fatto che siccome non viene compilato in linguaggio macchina ma al massimo in un linguaggio di medio livello è maggiormente portabile da un'architettura all'altra, o da un ambiente all'altro.

Il caso più evidente è quello di Java (che funziona allo stesso modo di C#): una volta che scrivi un programma java, lo puoi far girare sia in linux che windows senza modificare il codice: ovunque la macchina virtuale di java sia installata, java può girare.
Il problema del porting è infatti delegato ai programmatori che realizzano le macchine virtuali per le diverse piattaforme.

In C# questo vantaggio è meno evidente, essendo C# sostanzialmente destinato a girare solo in ambienti windows, ma si può constatare il vantaggio a un altro livello: tutti i linguaggi di .NET vengono compilati in uno stesso linguaggio (il CLI), quindi utilizzare uno o l'altro è solo una questione di preferenza, ma tecnicamente al basso livello non cambia niente. Perciò si possono facilmente mischiare.

> 4) Nelle scorse lezioni abbiamo visto i seguenti tipi di variabili: bool, byte, short, int, long. Spiega le loro caratteristiche (dimensione in bit, tipi di valore che possono contenere, utilizzo che ne viene fatto)

bool: può contenere unicamente due valori, true (1) oppure false (0).

Viene normalmente utilizzato per controllare il flusso del programma, cioè le variabili di tipo bool vengono solitamente passate a istruzioni di controllo come: if, while, ecc ecc...

Qualcuno potrebbe erroneamente pensare che la dimensione di un bool in memoria sia di un bit... e invece è di 8 bit, ovvero 1 byte.

byte: la sua dimensione (come il nome suggerisce) è di 1 byte e può contenere numeri interi da 0 a 255

short: la sua dimensione è di 2 byte (16 bit) e può contenere numeri interi da -32,768 a 32,767.

int: dimensione 4 byte (32 bit) e può contenere numeri interi da -2,147,483,648 a 2,147,483,647.

long: dimensione 8 byte (64 bit) e può contenere numeri interi da -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807

> scrivi un programma in cui ciascun tipo viene inizializzato al suo valore minimo, al suo valore massimo e al suo valore di default. Stampa sullo schermo i risultati.

static void Main(string[] args)
        {
            //Inizializziamo tutte le variabili
            bool minBool = false;
            bool maxBool = true;
            bool defaultBool = default(bool); //false

            byte minByte = byte.MinValue;
            byte maxByte = byte.MaxValue;
            byte defaultByte = default(byte);

            short minShort = short.MinValue;
            short maxShort = short.MaxValue;
            short defaultShort = default(short);

            int minInt = int.MinValue;
            int maxInt = int.MaxValue;
            int defaultInt = default(int);

            long minLong = long.MinValue;
            long maxLong = long.MaxValue;
            long defaultLong = default(long);



            //Stampiamo tutti i valori sulle console
            Console.WriteLine(string.Format("Il bool minimo è {0}", minBool));
            Console.WriteLine(string.Format("Il bool massimo è {0}", maxBool));
            Console.WriteLine(string.Format("Il bool di default è {0}", defaultBool));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("Il byte minimo è {0}", minByte));
            Console.WriteLine(string.Format("Il byte massimo è {0}", maxByte));
            Console.WriteLine(string.Format("Il byte di default è {0}", defaultByte));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("Lo short minimo è {0}", minShort));
            Console.WriteLine(string.Format("Lo short massimo è {0}", maxShort));
            Console.WriteLine(string.Format("Lo short di default è {0}", defaultShort));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("L'int minimo è {0}", minInt));
            Console.WriteLine(string.Format("L'int massimo è {0}", maxInt));
            Console.WriteLine(string.Format("L'int di default è {0}", defaultInt));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("Il long minimo è {0}", minLong));
            Console.WriteLine(string.Format("Il long massimo è {0}", maxLong));
            Console.WriteLine(string.Format("Il long di default è {0}", defaultLong));

            //Questa riga di codice serve a fare in modo che la console rimanga aperta fintanto che non premo enter
            Console.ReadLine();
        }

Il risultato

Il bool minimo è False
Il bool massimo è True
Il bool di default è False


Il byte minimo è 0
Il byte massimo è 255
Il byte di default è 0


Lo short minimo è -32768
Lo short massimo è 32767
Lo short di default è 0


L'int minimo è -2147483648
L'int massimo è 2147483647
L'int di default è 0


Il long minimo è -9223372036854775808
Il long massimo è 9223372036854775807
Il long di default è 0

Possiamo notare che tutti i tipi numerici hanno come valore di default lo 0.

Che cosa è il valore di default?
In certi casi C# inizializza automaticamente una variabile a un valore: questo valore è il valore di default del tipo.

Questo non avviene con le variabili locali (che devono essere sempre inizializzate in maniera esplicita), ma avviene per esempio con le variabili di classe (che vedremo più avanti).


> 5) Il byte è un tipo di variabile che può contenere numeri interi positivi.
> Dimostra che il valore minimo del byte è 0 e il valore massimo 255.
> La dimostrazione deve essere articolata in due parti:
> a) Dimostrazione matematica (suggerimento: è sufficiente la semplice matematica binaria, dal momento che il byte è solo per numeri positivi)

Il byte ha 8 bit, ovvero 8 ciffre.

Il primo passo quindi è trovare le prime 8 potenze di 2.

2⁰ = 1
2¹ = 2
2² = 4
2³ = 8
2⁴ = 16
2⁵ = 32
2⁶ = 64
2⁷ = 128

Il byte minimo ovviamente è quello in cui tutti i bit sono a 0, quindi: 0000 0000

Possiamo risicrviere il byte dall'alto al basso (la ciffra più a destra in cima alla "torre", quella più a sinistra in fondo alla torre) e quindi giustapporre ogni risultato della potenza di 2 alla posizione corrispondente

0 - 1
0 - 2
0 - 4
0 - 8
0 - 16
0 - 32
0 - 64
0 - 128

Moltiplichiamo i numeri a sinistra con quelli a destra

0*1 = 0
0*2 = 0
0*4 = 0
0*8 = 0
0*16 = 0
0*32 = 0
0*64 = 0
0*128 = 0

Poi dobbiamo sommare tutti i risultati... uno zero sommato con altri 0 ovviamente dà come risultato 0, quindi non facciamo nemmeno il calcolo.

Perciò il byte minimo è 0.

Ora calcoliamo il byte massimo: chiaramente è quelli in cui tutte le ciffre sono a 1, quindi: 1111 1111

Prendiamo quindi le potenze di 2 e mettiamoli in fila con le ciffre come fatto sopra, quindi moltiplichiamo ogni ciffra con la potenza di 2 corrispondente.

1*1 = 1
1*2 = 2
1*4 = 4
1*8 = 8
1*16 = 16
1*32 = 32
1*64 = 64
1*128 = 128

E quindi sommiamo i risultati

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255

Quindi abbiamo dimostrato che il byte massimo è 255, in linea con i risultati che ci ha dato il programma dell'esercizio precedente.

> b) Dimostrazione programmatica con C#: vedi esercizio 4.

Console.WriteLine(string.Format("Il byte massimo è {0}", byte.MaxValue));
Console.ReadLine();

> 6) Come il 5, ma sta volta per lo short.
> Dimostra che il valore massimo di uno short è 32'767.
> Suggerimento: dal momento che lo short può contenere sia valori negativi che positivi, la semplice matematica binaria non basta: la dimostrazione si deve avvalere del complemento a due, che tiene conto del segno.

Dal momento che lo short comprende anche numeri negativi (a differenza del byte), dobbiamo tenere conto anche del segno e la cosa si complica leggermente.

Nella semplice matematica binaria si potrebbe semplicemente mettere il segno (+ oppure -) davanti al numero, ma in una macchina dobbiamo codificare il segno all'interno del numero stesso (cioè, all'interno di un bit).

Lo short ha 16 bit, ma di questi 16 bit, uno lo dobbiamo usare per codificare il segno... e come spiegato, a codificare il segno è il bit più a sinistra.

0 = +
1 = -

Lo short massimo ovviamente sarà un numero positivo, quindi possiamo già annotrare che il bit più a sinistra sarà uno 0.

Ci restano quindi 15 bit, con i quali dobbiamo fare la stessa che abbiamo fatto sopra: metterli tutti a 1 per ottenere il massimo valore possibile, quindi abbiamo (metto il segno tra parentesi:

(0)111 1111 1111 1111

Ci servono le prime quindi le prime 15 pontenze di 2.

2⁰ = 1
2¹ = 2
2² = 4
2³ = 8
2⁴ = 16
2⁵ = 32
2⁶ = 64
2⁷ = 128
2⁸ = 256
2⁹ = 512
2¹⁰ = 1'024
2¹¹ = 2'048
2¹² = 4'096
2¹³ = 8'192
2¹⁴ = 16'384


Come nel precente esercizio, moltiplichiamo la ciffra con la potenza corrispondente. Non sto a ripetere il passaggio perché ê spiegato sopra: chiaramente moltiplicando tutti i valori sopra con 1, i valori restano uguali, quindi possiamo semplicemente sommarli direttamente.


1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 + 256 + 512 + 1'024 + 2'048 + 4'096 + 8'192 + 16'384 = 32'767

Quindi, 32'767 è il valore massimo di uno short.

Verifichiamolo con C#

Console.WriteLine(string.Format("Lo short massimo è {0}", short.MaxValue));
Console.ReadLine();

Esercizi completati. Domande?


**Modificato dall'autore il 01.06.2018 19:19**

**Modificato dall'autore il 03.06.2018 04:08**