first commit

Makefile

@@ -0,0 +1,15 @@
+PDFDIR=pdf
+MDS=$(wildcard *.md)
+PDFS=$(patsubst %.md,$(PDFDIR)/%.pdf, $(MDS))
+TEMPLATE_ARGS=-V titlepage=true -V titlepage-text-color=000000 -V titlepage-color=B2DFEE -V titlepage-background=./background.pdf
+PANDOC_ARGS=-N -V lang=it --template default.latex  -s --listings --toc
+
+.PHONY : all
+
+all : $(PDFS)
+
+$(PDFDIR):
+	mkdir $(PDFDIR)
+
+$(PDFDIR)/%.pdf: %.md $(PDFDIR)
+	pandoc $(TEMPLATE_ARGS) $(PANDOC_ARGS) $< -o $@

README.md

@@ -0,0 +1,8 @@
+# Introduzione al coding
+
+La dispensa introduce ai concetti fondamentali del coding attraverso
+il dialogo con un LLM (Large Language Model). Il percorso formativo
+parte dalla descrizione di un semplice script Python che implementa un
+cifrario di Cesare. Il modello di linguaggio utilizzato è
+**phind_v10_model**.
+

background.pdf

@@ -0,0 +1,69 @@
+%PDF-1.5
+%µí®û
+3 0 obj
+<< /Length 4 0 R
+   /Filter /FlateDecode
+>>
+stream
+xœeŽKÂ@@÷s
+. Â8†GpaÛE]¨÷OdÒØÖ4,ø=^x†ï	®w‚éS\=@C±šÁeí“yÀ˜kBsX²p1ÒèÇLHÄðÜ*†a
 ßr<C39F>¹œøÕ¬VUb/ÒLPÝ1D®È<ì¢?ç‘\u¢Þ³·jÚmlŽœïp$Ž$Š“~.g~,·òž·>å
+endstream
+endobj
+4 0 obj
+   150
+endobj
+2 0 obj
+<<
+   /ExtGState <<
+      /a0 << /CA 1 /ca 1 >>
+   >>
+>>
+endobj
+5 0 obj
+<< /Type /Page
+   /Parent 1 0 R
+   /MediaBox [ 0 0 595.275574 841.889771 ]
+   /Contents 3 0 R
+   /Group <<
+      /Type /Group
+      /S /Transparency
+      /I true
+      /CS /DeviceRGB
+   >>
+   /Resources 2 0 R
+>>
+endobj
+1 0 obj
+<< /Type /Pages
+   /Kids [ 5 0 R ]
+   /Count 1
+>>
+endobj
+6 0 obj
+<< /Creator (cairo 1.14.8 (http://cairographics.org))
+   /Producer (cairo 1.14.8 (http://cairographics.org))
+>>
+endobj
+7 0 obj
+<< /Type /Catalog
+   /Pages 1 0 R
+>>
+endobj
+xref
+0 8
+0000000000 65535 f 
+0000000564 00000 n 
+0000000264 00000 n 
+0000000015 00000 n 
+0000000242 00000 n 
+0000000336 00000 n 
+0000000629 00000 n 
+0000000756 00000 n 
+trailer
+<< /Size 8
+   /Root 7 0 R
+   /Info 6 0 R
+>>
+startxref
+808
+%%EOF

introduzione_al_coding.md

@@ -0,0 +1,301 @@
+---
+title: Introduzione al coding
+subtitle: Dialoghi con un modello di linguaggio
+author: Andrea Fazzi
+date: 10.02.2024
+urlcolor: blue
+---
+
+# Introduzione
+
+Attraverso il dialogo con un LLM (Large Language Model) si
+introdurranno i concetti fondamentali del coding a partire da un
+semplice script Python che implementa un cifrario di Cesare. Il
+modello di linguaggio utilizzato è **phind_v10_model**.
+
+# Lo script
+
+**Io:** In che linguaggio è scritto il seguente programma?
+
+```python
+def cesar_cipher(text, key):
+    result = ""
+
+    for i in range(len(text)):
+        char = text[i]
+
+        if char.isupper():
+            result += chr((ord(char) - 65 + key) % 26 + 65)
+        else:
+            result += chr((ord(char) - 97 + key) % 26 + 97)
+
+    return result
+
+text = input("Inserisci il testo da cifrare: ")
+key = int(input("Inserisci la chiave: "))
+
+print("Testo cifrato: ", cesar_cipher(text, key))
+```
+
+**llm**: Il programma è scritto in Python.
+
+# Il linguaggio Python
+
+**Io**: Parlami in maniera succinta del linguaggio di programmazione
+Python (massimo 100 parole).
+
+**llm**: Python è un linguaggio di programmazione ad alto livello,
+interpretato e orientato agli oggetti. Creato da Guido van Rossum nel
+1991, è noto per la sua sintassi leggibile e semplice, simile al
+linguaggio inglese, con influenze matematiche. È dinamicamente
+tipizzato e gestisce l'allocazione della memoria. Supporta vari stili
+di programmazione, tra cui procedurale, funzionale e orientato agli
+oggetti. Python è spesso utilizzato per lo sviluppo rapido di
+applicazioni, l'automazione, l'elaborazione dei dati e l'apprendimento
+automatico. Ha una vasta gamma di librerie standard e un'ampia
+comunità di sviluppatori.
+
+# Descrizione dello script
+
+**Io**: Descrivimi lo script. Cosa fa?
+
+**llm**: Lo script Python che hai fornito è un'implementazione di un
+cifrario di Cesare, un metodo di crittografia di sostituzione molto
+semplice. Il cifrario di Cesare sposta ogni lettera dell'alfabeto di
+un numero fissato di posizioni. Ad esempio, con una chiave di 1, 'A'
+diventa 'B', 'B' diventa 'C', ecc.
+
+Ecco come funziona lo script:
+
+- La funzione `cesar_cipher` prende due argomenti: `text`, la stringa
+  da cifrare, e `key`, la chiave di cifratura.
+- Per ogni carattere nel testo, controlla se è maiuscolo o minuscolo e
+  calcola il nuovo carattere cifrato sommando la chiave alla posizione
+  numerica ASCII del carattere originale, poi modulando per il numero
+  di lettere nell'alfabeto (26).
+- Restituisce la stringa cifrata.
+- All'utente viene chiesto di inserire il testo da cifrare e la
+  chiave.
+- Infine, lo script stampa il testo cifrato.
+
+# Variabili
+
+**Io**: Nello script sono utilizzati diversi concetti relativi al
+coding in generale. Sono presenti, ad esempio, alcune variabili alle
+quali vengono assegnati dei valori. A partire dallo script, spiegami in maniera succinta
+
+1. Cosa sono le variabili
+2. Come si assegna un valore ad una variabile
+3. I diversi tipi di variabile utilizzati nello script
+
+**llm**: 
+
+1. Le variabili sono locazioni di memoria con un nome e un valore
+associato. In Python, le variabili non devono essere dichiarate prima
+dell'uso; si creano semplicemente assegnando un valore ad un nome con
+l'operatore `=` [0][1].
+2. Per assegnare un valore ad una variabile, si utilizza l'operatore
+   di assegnazione `=`. Ad esempio, `result = ""` assegna una stringa
+   vuota alla variabile `result`. In Python, è possibile assegnare
+   valori di diversi tipi di dati a una variabile e il tipo di dato
+   verrà determinato automaticamente [0][1].
+3. Nel tuo script, ci sono vari tipi di variabili:
+   - `text`: è una stringa, poiché contiene testo che l'utente
+     inserirà tramite l'input.
+   - `key`: è un intero, poiché l'input dell'utente viene convertito
+     in un numero intero con `int()`.
+   - `char`: è un carattere, poiché estrai singoli caratteri dalla
+     stringa `text`.
+   - `result`: è anch'essa una stringa, poiché accumula i caratteri
+     cifrati [0][2].
+
+
+## Esercizio
+
+**Io**: Proponimi un esercizio per mettere in pratica l'utilizzo delle
+variabili in Python. L'esercizio dev'essere coerente con quanto mi hai
+spiegato in precedenza. Insieme alla traccia dell'esercizio, genera
+una soluzione in Python.
+
+**llm**:
+
+Esercizio:
+
+Scrivi uno script Python che calcoli l'area di un cerchio dato il
+raggio. Utilizza una variabile per memorizzare il raggio e un'altra
+per memorizzare l'area. Stampa l'area sul terminale.
+
+Soluzione:
+```python
+# Assegnazione del raggio alla variabile 'raggio'
+
+raggio =  5
+
+# Calcolo dell'area del cerchio utilizzando la formula:
+# area = pi * raggio^2
+# Nota: In Python, 'pi' è rappresentato come math.pi
+
+import math
+area = math.pi * raggio **  2
+
+# Stampa dell'area sul terminale
+print("L'area del cerchio con raggio", raggio, "è", area)
+```
+
+# Cicli
+
+**Io**: Nello script è presente un ciclo `for`. Parlami di questo
+costrutto e di come viene utilizzato nello script.
+
+**llm**: Nello script Python fornito, il costrutto `for` viene
+utilizzato per iterare su una sequenza, in particolare una
+stringa. Questo costrutto è comune in Python e funziona come un
+iteratore, consentendo di eseguire un blocco di codice per ogni
+elemento in una sequenza, come una lista, una tupla, un dizionario, un
+insieme o una stringa [0][1][2][3].
+
+Ecco come viene utilizzato nel tuo script:
+
+- `for i in range(len(text)):` - Il ciclo `for` itera sulla lunghezza
+  della stringa `text` utilizzando la funzione `range()`, che genera
+  una sequenza di numeri. In questo caso, `i` assume il valore di ogni
+  indice nella stringa `text` durante l'iterazione [2][3].
+- All'interno del ciclo, `char = text[i]` assegna il carattere
+  corrispondente all'indice `i` alla variabile `char`.
+- Successivamente, il codice controlla se il carattere è maiuscolo o
+  minuscolo e calcola il nuovo carattere cifrato basandosi sulla
+  posizione ASCII del carattere originale e sulla chiave fornita
+  dall'utente.
+- Il risultato viene accumulato nella stringa `result`, che viene poi
+  stampata alla fine dello script.
+
+Quindi, il ciclo `for` in questo script è fondamentale per applicare
+la cifratura di Cesare a ciascun carattere del testo fornito
+dall'utente.
+
+**Io**: Esistono altri modi per costruire in Python parti di codice
+iterative? Potresti prima elencarle e poi descrivermele succintamente?
+
+**llm**: Esistono diversi modi per costruire parti di codice iterative
+in Python oltre al ciclo `for`. Ecco alcuni dei più comuni:
+
+- Ciclo `while`: Si utilizza quando non si conosce in anticipo quante
+  volte il ciclo deve essere eseguito, ma si sa solo quando deve
+  terminare [1].
+- List comprehension: Una forma concisa per creare liste basate su
+  espressioni e cicli for [1].
+- Funzioni ricorsive: Chiamano se stesse per risolvere problemi che
+  possono essere scomposti in sottoproblemi più piccoli [1].
+- Generatori: Fanno parte delle iterazioni, ma sono più leggeri perché
+  non memorizzano tutti gli elementi in memoria, ma li producono su
+  richiesta [1].
+
+**Io**: Potresti riscrivere lo script utilizzando un ciclo `while` al
+posto del `for`?
+
+**llm**: Per riscrivere lo script utilizzando un ciclo `while` invece
+del `for`, puoi seguire questi passaggi:
+
+1. Inizializza una variabile, ad esempio `i`, con valore 0.
+2. Imposta una condizione per il ciclo `while` che controlla se `i` è
+   minore della lunghezza della stringa `text`.
+3. All'interno del ciclo `while`, esegui il codice che era
+   precedentemente all'interno del ciclo `for`, assicurandoti di
+   aggiornare il valore di `i` alla fine di ogni iterazione.
+4. Alla fine del ciclo, assicurati che `i` sia incrementato di 1.
+
+Ecco come potrebbe apparire lo script modificato:
+
+```python
+def cesar_cipher(text, key):
+    result = ""
+    i =  0
+
+    while i < len(text):
+        char = text[i]
+
+        if char.isupper():
+            result += chr((ord(char) -  65 + key) %  26 +  65)
+        else:
+            result += chr((ord(char) -  97 + key) %  26 +  97)
+
+        i +=  1
+
+    return result
+
+text = input("Inserisci il testo da cifrare: ")
+key = int(input("Inserisci la chiave: "))
+
+print("Testo cifrato: ", cesar_cipher(text, key))
+```
+
+In questo modo, il ciclo `while` continua a eseguire il blocco di
+codice fino a quando `i` è inferiore alla lunghezza del testo, che è
+equivalente al comportamento del ciclo `for` originale.
+
+## Esercizio
+
+**Io**: Proponimi un esercizio nel quale sia necessario utilizzare un
+ciclo `for`. Genera la soluzione dell'esercizio.
+
+**llm**:
+
+Esercizio:
+
+Scrivi uno script Python che stampi la somma dei primi n numeri naturali, dove n è un numero intero fornito dall'utente.
+
+Traccia dell'esercizio:
+
+1. Chiedi all'utente di inserire un numero intero `n`.
+2. Utilizza un ciclo `for` per sommare i numeri da  1 a `n`.
+3. Stampa la somma ottenuta.
+
+Soluzione in Python:
+
+```python
+# Chiedi all'utente di inserire un numero intero
+n = int(input("Inserisci un numero intero: "))
+
+# Inizializza una variabile per tenere traccia della somma
+somma =  0
+
+# Utilizza un ciclo for per sommare i numeri da  1 a n
+for i in range(1, n +  1):
+    somma += i
+
+# Stampa la somma ottenuta
+print("La somma dei primi", n, "numeri naturali è", somma)
+```
+
+**Io**: E' possibile scrivere un'implementazione ricorsiva dello
+stesso esercizio? Potresti eventualmente generarla e spiegarmi passo
+passo come funziona?
+
+**llm**:
+
+Esercizio: Scrivi uno script Python che, data un'intera positiva `n`,
+calcoli la somma dei primi `n` numeri naturali.
+
+Soluzione in Python:
+
+```python
+def sum_of_naturals(n):
+    # Caso base per la ricorsione: se n è  0, la somma è  0
+    if n ==  0:
+        return  0
+    # Somma del numero corrente più la somma dei numeri successivi
+    else:
+        return n + sum_of_naturals(n -  1)
+
+n = int(input("Inserisci un numero intero positivo: "))
+
+print("La somma dei primi", n, "numeri naturali è", sum_of_naturals(n))
+```
+
+In questa soluzione, la funzione `sum_of_naturals` è una funzione
+ricorsiva che calcola la somma dei primi `n` numeri naturali. La
+ricorsione avviene quando la funzione si chiama se stessa con un
+valore ridotto di `n` (da `n` a `n - 1`) fino a raggiungere il caso
+base in cui `n` è 0, altrimenti la somma viene calcolata sommando `n`
+al risultato della chiamata ricorsiva.
+