Tag: Mondo codice 🖥

  • JavaScript: come fare le richieste HTTP(S)

    JavaScript: come fare le richieste HTTP(S)

    Esplorando l’universo delle richieste HTTP con JavaScript: la guida definitiva per programmare con stile.

    Scopri come cavalcare le onde del web con l’oggetto XMLHttpRequest e la nuova API fetch, e impara a dialogare con i server come un vero hacker del nuovo millennio. Abbandona le vecchie tecniche una volta per sempre, e lasciati cullare dalla potenza della programmazione moderna, dove ogni richiesta diventa un’esperienza emozionante e appagante per il tuo codice.

    L’evoluzione della nostra capacità di interagire con i server utilizzando JavaScript è stata sorprendente. Grazie alla comunità di sviluppatori sempre più attiva, vengono introdotti nuovi strumenti per semplificare il processo. I metodi esposti in questo tutorial non si limitano solo all’interazione con i server remoti, ma possono essere applicati anche nella creazione di applicazioni web full-stack, interagendo con i propri server. Essi sono compatibili con numerose librerie e framework JavaScript.

    In questo tutorial, andremo a vedere come effettuare richieste HTTP in JavaScript attraverso vari esempi e spiegazioni, mostrando come utilizzare i metodi integrati e librerie di terze parti per inviare richieste GET, POST, PUT/PATCH e DELETE.

    HTTP request in Javascript: cosa sono e come funzionano

    Prima di iniziare è bene riprendere un po’ di fondamentali.

    In JavaScript, le richieste HTTP sono una serie di metodi predefiniti che ci permettono di interagire con i dati memorizzati sui server. Ogni richiesta include un endpoint e un tipo di richiesta che funge da gateway tra il client e il server. Il client, ovvero il programma che invia la richiesta, riceve una risposta dal server in base alla validità della richiesta inviata. In caso di successo, i dati vengono restituiti in formato XML o JSON (di solito JSON). In caso di fallimento, invece, il server invia un messaggio di errore. Il server comunica lo stato della risposta attraverso dei codici che ci aiutano a comprendere cosa sta cercando di dirci. Essi vanno da 100 a 199 per le risposte informative, da 200 a 299 per le richieste andate a buon fine, da 300 a 399 per i reindirizzamenti, da 400 a 499 per gli errori del cliente e da 500 a 599 per gli errori del server.

    Nota: i seguenti esempi valgono per estensione per qualsiasi POST, PUT, GET, DELETE, PATCH: semplicemente basta sostituire a GET o POST la chiamata desiderata.

    Richieste HTTP in JS usando XMLHttpRequest

    XMLHttpRequest è un oggetto di JavaScript integrato nel browser per interagire con i server e caricare contenuti delle pagine web senza ricaricare il browser. In questa sezione, impareremo come utilizzare XMLHttpRequest per inviare richieste POST, GET, PUT/PATCH e DELETE. AJAX è la tecnologia per effettuare richieste HTTP in modo asincrono, il che significa che altre parti del codice JavaScript possono continuare a funzionare mentre si attende la risposta della richiesta.

    Questa modalità rimane tra le più usate e comode, in quanto garantisce massima efficenza all’app ed evita di bloccarla inutilmente durante l’esecuzione. Inoltre, è possibile apportare modifiche a una sezione specifica della pagina senza dover ricaricare l’intera pagina, grazie all’uso di AJAX con XMLHttpRequest come oggetto predefinito.

    Nota: DummyJson.com è il sito che permette di effettuare i test, in questa guida, e restituisce una JSON farlocca che potete usare per programmare quando non avete dati reali a disposizione.

    Con questo codice carichiamo un nuovo oggetto XMLHttpRequest, facciamo una GET su una URL di prova, inviamo la richiesta; poi specifichiamo il tipo di risposta come JSON, e attendiamo il caricamento con la funzione onload. Se lo status è corretto e la chiamata è stata fatta, verrà stampata la JSON nella console, diversamente mostreremo l’errore che ci sta dando il server remoto.

    Il metodo funziona sia con protocollo sicuro HTTPS che con HTTP tradizionale, a seconda di quello che supporta il server.

    const xhr = new XMLHttpRequest();
    xhr.open("GET", "https://dummyjson.com/products/1");
    xhr.send();
    xhr.responseType = "json";
    xhr.onload = () => {
      if (xhr.readyState == 4 && xhr.status == 200) {
        const data = xhr.response;
        console.log(data);
      } else {
        console.log(`Error: ${xhr.status}`);
      }
    };

    Il risultato sarà mostrato in questa forma nella console, come stringa JSON.

    Ovviamente se volessimo fare una POST, in caso, basta sostituire nella seconda riga  GET con POST, mentre la condizione può essere riscritta per riconoscere i vari tipi di codici di stato lato server.

    Richieste HTTP in JS usando jQuery post (metodo consigliato)

    Nulla in contrario all’uso di ssss, ma è un sistema lungo e per certi versi un po’ verboso; meglio sintetizzare, soprattutto in informatica.Cosa che possiamo fare con jQuery, che andremo adesso ad analizzare nello specifico.  Per fare la stessa cosa usando jQuery – parliamo request HTTP in JS, lo ricordiamo – ovviamente dobbiamo includerlo, come prima cosa, nel markup della pagina, e poi eseguire qualcosa del genere:

    const body = JSON.stringify({
      title: "Hello World",
      body: "My POST request",
      userId: 900,
    });
    $.post("https://dummyjson.com/products/1", body, (data, status) => {
      console.log(data);
    });

    Nota: in alcuni siti la sintassi con $ potrebbe non funzionare, motivo per cui basterà sostituire nel codice tutte le occorrenze di $. con jQuery. in modo da risolvere l’ambiguità.

    Nel blocco di codice precedente, abbiamo creato una scintillante gemma di dati da spedire al nostro server, e l’abbiamo conservata in una variabile chiamata “body“. Questa preziosa variabile è stata quindi offerta in sacrificio come secondo parametro al glorioso metodo $.post(). Mentre il messaggero portava il nostro prezioso carico al cospetto del server, abbiamo affidato il compito di ricevere la risposta a una funzione callback. E così, con la grazia divina della console, abbiamo finalmente registrato il risultato della nostra epica richiesta.

    Richieste HTTP in JS usando jQuery / ajax

    Con l’aiuto di $.ajax(), in alternativa, possiamo fare la stessa cosa ed ottenere lo stesso effetto.

    $.ajax({
    url: "https://jsonplaceholder.typicode.com/users",
    type: "GET",
    success: function (result) {
    console.log(result);
    },
    });

    Credits: immagine di copertina generata da StarryAI.

  • Pattern in Programmazione: cosa sono e come si utilizzano

    Pattern in Programmazione: cosa sono e come si utilizzano

    Introduzione

    Nel vasto mondo della programmazione, il termine “pattern” riveste un ruolo cruciale. I pattern sono soluzioni consolidate a problemi comuni che si presentano nella progettazione e nello sviluppo del software. In questo articolo, esploreremo cosa sono i pattern in programmazione, come nasce la programmazione a pattern e perché sono essenziali per la creazione di software di alta qualità.

    Cosa vuol dire pattern?

    In generale, un “pattern” è una soluzione generale e riutilizzabile a un problema comune che si verifica in un determinato contesto o dominio. I pattern offrono una guida strutturata per risolvere problemi specifici, facilitando la progettazione e lo sviluppo del software.

    Ecco alcuni punti chiave per comprendere cosa sia un pattern:

    1. Soluzione a Problemi Comuni: I pattern affrontano problemi che si verificano spesso nello sviluppo del software. Questi problemi possono riguardare la progettazione di classi, la gestione delle relazioni tra oggetti, la gestione dello stato, la gestione degli eventi, e molto altro.
    2. Approccio Riutilizzabile: I pattern sono progettati per essere riutilizzabili in diverse situazioni. Una volta identificato un problema che corrisponde a un determinato pattern, è possibile applicarlo senza dover reinventare la soluzione ogni volta.
    3. Documentazione delle Migliori Pratiche: I pattern rappresentano le migliori pratiche consolidate nel settore dello sviluppo del software. Sono il risultato dell’esperienza e delle conoscenze condivise dagli sviluppatori nel corso degli anni.
    4. Concetti Standardizzati: I pattern sono descritti mediante una terminologia standardizzata che consente agli sviluppatori di comunicare in modo più chiaro e conciso riguardo alle soluzioni utilizzate.
    5. Adattabilità: Benché i pattern abbiano una struttura generale, possono essere adattati e personalizzati per soddisfare le esigenze specifiche di un’applicazione o di un progetto.
    6. Applicabilità Multiplice: Un pattern può essere applicato in molte situazioni diverse. Ad esempio, il “Pattern Singleton” può essere utilizzato per garantire che una classe abbia una sola istanza, indipendentemente dal contesto.
    7. Catalogo di Pattern: Esiste un vasto catalogo di pattern ben noti, come il “Pattern Singleton,” il “Pattern Factory Method,” il “Pattern Observer,” il “Pattern Strategy” e molti altri, ognuno dei quali è adatto a risolvere problemi specifici.

    In sintesi, un pattern rappresenta una soluzione collaudata e riutilizzabile a un problema comune nel mondo della programmazione e del design del software. L’uso di pattern consente agli sviluppatori di scrivere codice più efficiente, manutenibile e scalabile, riducendo al contempo il rischio di errori e migliorando la coerenza nel codice.

    Cosa Sono i Pattern in Programmazione?

    Un “pattern” in programmazione è una soluzione progettata per risolvere problemi specifici che si verificano frequentemente nello sviluppo del software. Queste soluzioni sono il risultato di esperienze passate e buone pratiche condivise tra gli sviluppatori. I pattern offrono un modo standardizzato e affidabile per affrontare problemi ricorrenti.

    Origini della Programmazione a Pattern

    La programmazione a pattern ha radici che risalgono agli anni ’70, ma è stata formalizzata e resa popolare da due libri influenti: “Design Patterns: Elements of Reusable Object-Oriented Software” di Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides (noto come il libro dei “Gang of Four”) e “Patterns of Enterprise Application Architecture” di Martin Fowler. Questi testi hanno fornito una base solida per la comprensione e l’adozione dei pattern nella progettazione del software.

    Perché sono Importanti i Pattern nella Programmazione?

    I pattern offrono una serie di vantaggi cruciali nella programmazione:

    1. Riutilizzo del Codice: Consentono di riutilizzare soluzioni collaudate, risparmiando tempo e sforzi nello sviluppo.
    2. Chiarezza del Codice: Rendono il codice più leggibile e comprensibile, poiché seguono convenzioni ben note.
    3. Manutenibilità: Facilitano la manutenzione del software, in quanto problemi noti sono gestiti in modo predefinito.
    4. Scalabilità: Sono adattabili alle dimensioni e alla complessità del progetto, fornendo una struttura solida per l’espansione.

    Esempi di Pattern

    Alcuni esempi di pattern comuni includono:

    • Il Singleton Pattern: Garantisce che una classe abbia una sola istanza e fornisce un punto di accesso globale ad essa.
    • Il Pattern Observer: Consente a un oggetto di notificare una serie di oggetti “osservatori” quando cambia il suo stato.
    • Il Pattern Factory Method: Definisce un’interfaccia per la creazione di oggetti, ma lascia alle sottoclassi la scelta delle classi da istanziare.
    • Il Pattern Strategy: Consente di definire una famiglia di algoritmi, incapsularli e renderli intercambiabili.

    Esempi pratici di pattern in linguaggio Python

    Ecco alcuni esempi pratici di pattern comuni in Python:

    1. Singleton Pattern: Il Singleton Pattern (singoletto) viene utilizzato quando si desidera che una classe abbia una sola istanza durante l’intera esecuzione del programma. Questo è utile quando è necessario condividere una risorsa unica tra diverse parti del codice. Ecco un esempio di implementazione di un Singleton in Python:
    class Singleton:
        _instance = None
    
        def __new__(cls):
            if cls._instance is None:
                cls._instance = super(Singleton, cls).__new__(cls)
            return cls._instance
    # Utilizzo del Singleton
    s1 = Singleton()
    s2 = Singleton()
    
    print(s1 is s2)  # Restituirà True, poiché s1 e s2 sono la stessa istanza.
    
    1. Observer Pattern: Il Pattern Observer (osservatore) è utilizzato per implementare il sistema di notifica in cui un oggetto notifica una serie di “osservatori” quando il suo stato cambia. Ecco un esempio molto semplice:
    class Subject:
        def __init__(self):
            self._observers = []
    
        def attach(self, observer):
            self._observers.append(observer)
    
        def detach(self, observer):
            self._observers.remove(observer)
    
        def notify(self):
            for observer in self._observers:
                observer.update()
    
    class Observer:
        def update(self):
            print("Sono stato notificato di un cambiamento!")
    
    subject = Subject()
    observer1 = Observer()
    observer2 = Observer()
    
    subject.attach(observer1)
    subject.attach(observer2)
    
    subject.notify()
    1. Factory Method Pattern: Il Factory Method Pattern è utilizzato per definire un’interfaccia per la creazione di oggetti, ma lascia alle sottoclassi la scelta delle classi da istanziare. Ecco un esempio:


    from abc import ABC, abstractmethod

    class Creator(ABC):
    @abstractmethod
    def factory_method(self):
    pass
    
    def some_operation(self):
    product = self.factory_method()
    result = f"Creator: {product.operation()}"
    return result
    
    class ConcreteCreator1(Creator):
    def factory_method(self):
    return ConcreteProduct1()
    
    class ConcreteCreator2(Creator):
    def factory_method(self):
    return ConcreteProduct2()
    
    class Product(ABC):
    @abstractmethod
    def operation(self):
    pass
    
    class ConcreteProduct1(Product):
    def operation(self):
    return "Prodotto 1"
    
    class ConcreteProduct2(Product):
    def operation(self):
    return "Prodotto 2"
    
    def client_code(creator):
    print(creator.some_operation())
    
    client_code(ConcreteCreator1()) # Creerà e utilizzerà ConcreteProduct1
    client_code(ConcreteCreator2()) # Creerà e utilizzerà ConcreteProduct2

    Questi sono solo alcuni esempi di pattern in Python. Ogni pattern ha un obiettivo specifico e può essere applicato in diverse situazioni per migliorare la struttura e la manutenibilità del codice.

    Conclusione

    I pattern in programmazione sono strumenti fondamentali per la progettazione e lo sviluppo di software efficienti, manutenibili e scalabili. Essi rappresentano un patrimonio di conoscenze accumulato nel corso degli anni dagli sviluppatori e offrono una guida preziosa per affrontare problemi comuni. La comprensione e l’adozione dei pattern sono fondamentali per diventare sviluppatori di software di successo e contribuire alla creazione di applicazioni di alta qualità.

  • Java: la guida per iniziare da zero

    Java: la guida per iniziare da zero

    Ti serve Java sul computer ma non vuoi imparare a programmare? Nessun problema.

    In questa guida trovi solo quello che ti serve: installare Java, configurarlo e farlo partire su Windows, Linux e macOS.

    Niente teoria, niente codice inutile.

    Solo il minimo per farlo funzionare!

    In alternativa, puoi usare un compilatore Java pronto all’uso da browser, senza installare nulla, il che va bene almeno per i progetti piccoli.

    Usi WINDOWS?

    1. Scarica Java (JDK)

    • Vai su https://jdk.java.net
    • Scarica la versione LTS più recente (es. Java 21) per Windows
    • Oppure usa Oracle, Adoptium, Amazon Corretto (sono tutte distribuzioni compatibili)

    2. Installa

    • Esegui il file .msi o .exe
    • L’installer ti guiderà. Accetta tutto, installa.

    3. Imposta le variabili d’ambiente

    • Cerca “variabili d’ambiente” su Start → “Modifica variabili d’ambiente del sistema”
    • Aggiungi JAVA_HOME:
      • Valore: C:\Program Files\Java\jdk-21 (o quello che hai installato)
    • Modifica il Path:
      • Aggiungi C:\Program Files\Java\jdk-21\bin

    4. Verifica

    Apri il Prompt dei comandi (cmd) e scrivi:

    java -version
    
    javac -version
    

    Se tutto funziona, vedi la versione installata.

    Usi LINUX (Ubuntu / Debian)?

    1. Installa via terminale

    sudo apt update
    sudo apt install openjdk-21-jdk
    

    2. Verifica

    java -version
    javac -version
    

    3. (Opzionale) Imposta JAVA_HOME

    sudo nano /etc/environment
    

    Aggiungi alla fine:

    JAVA_HOME="/usr/lib/jvm/java-21-openjdk-amd64"
    

    Poi:

    source /etc/environment
    

    Usi macOS

    1. Usa Homebrew (consigliato)

    Se non hai Homebrew:

    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    

    Poi installa Java:

    brew install openjdk@21
    

    2. Configura

    Homebrew ti dirà dove Java è stato installato. Ad esempio:

    echo 'export PATH="/opt/homebrew/opt/openjdk@21/bin:$PATH"' >> ~/.zprofile
    echo 'export CPPFLAGS="-I/opt/homebrew/opt/openjdk@21/include"' >> ~/.zprofile
    

    Poi:

    source ~/.zprofile
    

    3. Verifica

    java -version
    javac -version
    

    ✅ Java installato e pronto

    Ora puoi eseguire file .java con:

    javac NomeFile.java     # compila
    java NomeFile           # esegue
    

    Non ti serve altro per farlo girare.

    Codice minimale e funzionante in Java

    Ecco un esempio minimo di file .java per testare che tutto funzioni: un HelloWorld.java che più breve non si potrebbe.

    Hello.java

    public class Hello {
        public static void main(String[] args) {
            System.out.println("Funziona!");
        }
    }
    

    ▶️ Come eseguirlo (vale su Windows, Linux, macOS)

    1. Apri un terminale o prompt dei comandi
    2. Vai nella cartella dove hai salvato Hello.java

    Esegui:

    javac Hello.java
    

    Questo crea un file Hello.class

    Poi:

    java Hello
    

    Dovresti vedere:

    Funziona!
    

    Hai Java installato, compilato e in esecuzione. Fine.

    E per gli amanti del metal…

     

  • Come configurare OPCache per PHP

    Come configurare OPCache per PHP

    OPCache è un ottimizzatore PHP molto sfruttato per via della sua relativa facilità  d’uso, e rende i siti web tendenzialmente più veloci di quanto non sarebbero con la versione di PHP standard. La necessità  di ricorrere a OPCache in PHP nasce da un requisito storicamente molto criticato del PHP stesso, ovvero il fatto che sia un linguaggio interpretato: in altri termini, al momento dell’esecuzione di uno script PHP (parte del processo di uso di WordPress o “in solitaria”) uno stesso frammento può essere compilato ed interpretato più volte, comportando un potenziale spreco di risorse (RAM e CPU).

    Requisiti

    Utilizzare PHP versione 7.4 o successive. Per verificare la versione di PHP utilizzata potete verificarlo dal cPanel del vostro sito (o dal Plesk, a seconda dei casi), oppure con il comando da terminale

    php -v

    che dovrà  restituire una versione almeno 5.5.0. Se non ce l’avete, dovreste aggiornare PHP all’ultima versione seguendo la guida che ho appena linkato in questo articolo.

    Vantaggi di OpCache

    OPcache è un modulo che migliora le performance di PHP sfruttando una complessa architettura informatica precompilata, riducendo il numero di volte in cui, durante il caricamento di una pagina, PHP ha bisogno di richiamare più volte gli stessi script. Si tratta quindi di un’ottimizzatore automatizzato per il codice PHP, che potete usare anche in WordPress allo scopo di provare a migliorare i tempi di caricamento e, in alcuni casi, anche il PageSpeed Insights.

    Installare OpCache

    OpCache potrebbe non essere disponibile nel vostro servizio di hosting, per cui andrebbe richiesto al servizio stesso di abilitarvelo. Cosa che potete fare anche da VPS, volendo, seguendo la procedura seguente.

    Enabling OPcache

    Per abilitare OPcache, dopo aver installato l’ultima versione di PHP disponibile (poniamo che sia la 7.4, ad esempio) andiamo ad editare il file PHP.ini con l’editor SSH nano:

    sudo nano /etc/php/7.4/apache2/php.ini

    Se usate NGINX o comunque PHP-FPM, invece:

    sudo nano /etc/php/7.4/fpm/php.ini

    Abilitare OPcache è molto semplice: cercate questa riga

    ;opcache.enable=0

    e sostituitela con quest’altra

    opcache.enable=1

    facendo attenzione a togliere di mezzo il ; iniziale, qualora fosse presente. Usciamo da nano (CTRL X) e poi   riavviamo Apache:

    sudo service apache2 restart

    oppure Nginx, a seconda di quello che usate

    sudo service nginx restart

    Per verificare che OPcache funzioni correttamente, andate a creare un file phpinfo.php nella root del vostro sito (ad esempio (/var/www/html) inserite il seguente codice:

    <?php phpinfo(); ?>

    uscite dall’editor, salvando prima di uscire, e provate ad aprire il file tuosito.com/phpinfo.php; dovreste vedere da qui una sezione OpCache che confermerà  che è tutto ok e funzionante.

    Configurare OpCache con WordPress

    Potete installare e gestire OpCache in WordPress in modo automatico, con il controllo sulla flush della cache, sfruttando il plugin gratuito:

    WP OpCache

    Configurare OpCache nel dettaglio

    Per garantire buoni livelli di performance del sito, è consigliabile inserire le seguenti direttive nel file PHP.ini:

    opcache.memory_consumption=128
    opcache.interned_strings_buffer=8
    opcache.max_accelerated_files=4000
    opcache.revalidate_freq=60
    opcache.fast_shutdown=1
    opcache.enable_cli=1

    Per sapere quale file PHP.ini modificare e dove si trova, basta verificare mediante il comando phpinfo() che restituisce, tra l’altro, il path correntemente usato dal sistema per il file PHP.ini.   Altri piccoli miglioramenti si possono ottenere sfruttando le seguenti dritte di massima, che restano ovviamente valide solo come indicazione generale:

    ; da tarare sul numero di file di WordPress effettivi presenti nel sito: contiamoli
    sfruttando il comando find . -type f -iname *.php | wc -l
    opcache.max_accelerated_files=9500
    ; queste sono impostazioni da testare su una droplet VPS con 1 GB di RAM, ad esempio
    opcache.memory_consumption=192
    opcache.interned_strings_buffer=8

    Su altre guide alla configurazione di opcache, consigliano queste impostazioni:

    opcache.revalidate_freq=0
    opcache.validate_timestamps=0
    opcache.max_accelerated_files=7963
    opcache.memory_consumption=192
    opcache.interned_strings_buffer=16
    opcache.fast_shutdown=1
  • Come configurare la memoria virtuale su una VPS (SWAP)

    Come configurare la memoria virtuale su una VPS (SWAP)

    Questo articolo tratterà  pro e contro dell’utilizzo della memoria virtuale, o del relativo file di swap (paging o paginazione della memoria virtuale), determinando:

    • se la tua VPS utilizza o meno la memoria virtuale;
    • le differenze tra una partizione di swap e un file di swap
    • dandovi informazioni su come creare un file di scambio e come configurare la memoria virtuale del sistema.

    Swap e memoria virtuale, in effetti, sono due caratteristiche poco note e molto utili per configurare al meglio il nostro sito: con la memoria virtuale, infatti, il sistema sarà  in grado di sopperire alla mancanza di RAM sfruttando una parte di spazio su disco. Stando alla teoria, inoltre, il cosiddetto paging risponde esattamente a questo requisito, impostando dei requisiti per uno scambio veloce ed efficiente.

    Lo swap è una caratteristica sfruttabile anche a livello di siti web, in quanto i siti con alto utilizzo di RAM tendono a cadere facilmente, o comunque a rallentare i tempi di caricamento delle pagine. In particolare questa caratteristica dello swap viene molto usata sugli hosting con hard disk in SSD.

    Immaginiamo di avere un VPS con (ad esempio) 512MB di RAM a disposizione, e sistema operativo Debian. All’interno della finestra del terminale SSH avremo a disposizione vari task e vari processi attivi, che occuperanno memoria variabile in base ai rispettivi requisiti.   Sui server in produzione, cioè quelli relativi a siti web già  online che girino su hosting VPS, tipicamente la memoria virtuale non è attiva, e deve essere impostata adeguatamente.

    In questo modo non saremo costretti, compatibilmente non lo spazio a disposizione sul server, ad estendere la memoria RAM passando a piani VPS più costosi.

    Requisiti

    Per effettuare queste operazioni vi serviranno:

    1. un terminale di comando o PuTTY;
    2. accesso root via SSH al sito;
    3. i comandi da terminale free, swapon, swapoff, dd, mkswap

    La memoria virtuale in realtà  potrebbe essere stata già  configurata, ma in questa guida vedremo come impostarla o reimpostarla a dovere. La regola empirica generale è quella di dimensionare lo swap fino a 2 volte la dimensione della RAM disponibile: ad esempio, se avete un VPS con 512MB di RAM, potete impostare lo swap con altri 512MB minimo e 1.5GB al massimo, per un totale di memoria a disposizione di 1 GB minimo e di 2 GB al massimo.

    Vantaggi e svantaggi dello swap su VPS Linux

    Se usate le droplet di DigitalOcean, cosa che faccio anch’io ad esempio, sono con hard disk SSD e non soffrono particolarmente di problemi di lentezza lato server. In alcuni casi, pero’, ad esempio su un sito configurato con NGINX, l’uso di RAM era molto più alto di quello di un server Apache, e quindi la configurazione dello swap era indispensabile per evitare l’insorgere (ad esempio) di rallentamenti sul sito oppure errori 500 e/o 530.

    Vantaggi

    • Maggiore memoria disponibile per il sito, il che si traduce in prestazioni “mediamente” migliori
    • evitare problemi di stack overflow o di out of memory;
    • velocizzare i tempi di caricamento delle pagine web ed il TTFB

    Svantaggi

    • Problemi nella gestione del disco fisso che tende a ridursi lato web (ad es. /var/www/html)
    • Errori di configurazione che possono compromettere il funzionamento del sito, ad esempio per imperizia dell’operatore.

    Procedura passo-passo: verificare lo spazio a disposizione

    Come prima cosa, da terminale di comando lanciate il comando:

    free

    per verificare la memoria disponibile. Vedrete una tabella testuale con l’indicazione della memoria totale (total), di quella usata (used), di quella libera (free), del buffer (buffers) e della cache (cached). Questo si ripeterà  per tutte le partizioni disponibili, al limite solo per l’unica che avete a disposizione.

    Se è abilitata vedremo una cosa del genere:

                 total       used       free     shared    buffers     cached
    Mem:        361996     360392       1604          0       1988      54376
    -/+ buffers/cache:     304028      57968
    Swap:       249896          0     249896
    

    Se non lo è, free restituirà  qualcosa del genere:

                 total       used       free     shared    buffers     cached
    Mem:        361996     360392       1604          0       2320      54444
    -/+ buffers/cache:     303628      58368
    Swap:            0          0          0
    
    

    Potete anche vedere solo lo swap usando il comando alternativo:

    free | grep Swap

    Creare il file di swap

    Usate il comando df -h per vedere le informazioni sul disco della VPS. Il file di swap dovrebbe essere inserito in /var come ad esempio swap.img (che sarà  il file della memoria virtuale gestito dal sistema). Quindi entriamo in /var, creiamo un file swap e lo impostiamo con permessi chmod a 600 per motivi di sicurezza.

    cd /var
    touch swap.img
    chmod 600 swap.img
    
    

    Dimensionare il file di swap

    Come abbiamo scritto prima, se avete 0.5G di RAM fisica a disposizione, potete impostare la dimensione del file di swap fino a circa 1.5GB / 2.0GB. Ovviamente dovrete assicurarvi di avere a disposizione tale spazio sul disco, cosa che potete fare pulendo i file temporanei da ogni cartella, riducendo plugin installati, theme inutili, la dimensione delle immagini di WordPress e così via.

    Sulle droplet di DigitalOcean può essere opportuno dimensionare il file con tutti zeri:

    dd if=/dev/zero of=/var/swap.img bs=1024k count=1000
    

    Inizializzare il disco

    Impostiamo la memoria virtuale ad 1 GB (come scritto al passaggio precedente):

    mkswap /var/swap.img

    In alternativa potete sfruttare fallocate (dopo averlo installato con ccc) per indicare direttamente la dimensione desiderata dello swap.

    sudo fallocate -l 1G /swapfile

    Abilitare lo swap

    Per abilitare lo swap

    swapon /var/swap.img

    Per disbailitarlo:

    swapoff /var/swap.img

    Potete verificare che lo swap sia attivo dando di nuovo il comando free.

    Abilitare lo swap in automatico

    Quello che bisogna fare come ultimo passaggio, è aggiungere una riga al file /etc/fstab per abilitare la cosa.

    Attenzione che questa operazione va effettuata con molta attenzione, per cui leggete un po’ di documentazione su fstab prima di procedere.

    Il comando è questo, in genere:

    echo "/var/swap.img    none    swap    sw    0    0" >> /etc/fstab
    
  • Django: il CMS open source in Python

    Django: il CMS open source in Python

    Che cos’è Django

    Si tratta di un CMS open source scritto in Python, che richiede minore scrittura del codice rispetto al classico PHP e che si appoggia su framework eventualmente scritti in altri linguaggi. Il CMS Django presenta infatti struttura modulare e blocchi (simili a quelli di Drupal, per intenderci), librerie pronte ad essere integrate e già  collaudate.

    Leggi la guida

    Siti famosi fatti in Django

    Django è anche il nome del framework scritto in Python che è utile per farne uso e programmarlo a piacere, mentre molti siti famosi ne hanno fatto uso: Instagram versione web, ad esempio, ma anche il sito ufficiale di Mozilla e BitBucket.

    Come funziona Django

    Creato nel 2003, è una delle applicazioni più elaborate ed ambiziose in Python, e ne dimostra la sua ampia versatilità . Dal 2015 è un progetto sostenuto e finanziato dalla DSF (Django Software Foundation). Django CMS si basa sul modello di sviluppo denominato Model-View-Controller o MVC, il quale permette di mantenere separata la linea di codice dalla strutturazione dei dati e dalla vista web che viene presentata dagli stessi. Grazie a questo modello, progettista, programmatore e grafico web possono lavorare in sinergia per la creazione di CMS altamente personalizzati.

    Più nello specifico, Django è costituito da un ORM (Object Relational Mapper) che realizza un “ponte” di collegamento tra le classi Python che fanno da “contenitori” o modelli di dati per il database relazionale, e poi fornisce gli strumenti per elaborare le richieste HTTP mediante un controller basato sulle regex (espressioni regolari). Sono inoltre inclusi nel framework principale:

    • un server web stand alone da usare per sviluppo e test
    • un sistema di serializzazione e convalida dei moduli in grado di salvare, codificare e modificare moduli HTML e rappresentazione degli stessi nel db;
    • un sistema di internazionalizzazione per le traduzioni;
    • un parser integrato in JSON e XML;
    • modelli basati sul paradigma della programmazione ad oggetti;
    • un sistema avanzato di cache;
    • un dispatcher di eventi;
    • template espandibili e personalizzabili;
    • eventuale supporto al middleware;
    • supporto alla creazione di web service.

    Per far funzionare Django, infine, si può installare in locale (localhost) oppure acquistare un servizio di hosting specifico per Django.

  • Guida veloce al design pattern

    Guida veloce al design pattern

    Un design pattern, nell’ambito della programmazione e dell’ingegneria del software, è una soluzione generica e riutilizzabile a un problema comune che si verifica frequentemente durante la progettazione e lo sviluppo del software. I design pattern forniscono una guida su come affrontare determinati scenari o problemi e offrono una struttura e una metodologia per creare codice ben strutturato, modulare e manutenibile.

    Storia dei Design Pattern:

    L’idea dei design pattern è stata introdotta nel campo della programmazione da tre autori: Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, noti collettivamente come “Gang of Four” (GoF). Nel loro libro del 1994 intitolato “Design Patterns: Elements of Reusable Object-Oriented Software”, essi hanno definito e descritto 23 design pattern fondamentali.

    I design pattern presentati nel libro rappresentano soluzioni ai problemi comuni nell’ambito dell’object-oriented design e della programmazione. Questi pattern sono stati catalogati, analizzati e documentati in modo che i programmatori potessero capirli, implementarli e applicarli alle loro attività di sviluppo.

    Uso e Utilità dei Design Pattern:

    I design pattern hanno una serie di utilizzi e utilità all’interno dello sviluppo software:

    1. Soluzioni Testate: I design pattern rappresentano soluzioni che sono state utilizzate e testate in molteplici scenari. Questo riduce il rischio di introdurre errori comuni e consente di beneficiare dell’esperienza accumulata da altri sviluppatori.
    2. Comunicazione: I design pattern offrono un linguaggio comune per descrivere soluzioni architetturali complesse. Ciò semplifica la comunicazione all’interno dei team di sviluppo e tra i membri di diverse discipline.
    3. Struttura Chiara: L’uso dei design pattern promuove una struttura chiara e organizzata all’interno del codice. Questo facilita la manutenzione, l’aggiornamento e l’espansione del software nel tempo.
    4. Riusabilità: I design pattern promuovono la riusabilità del codice. Una volta che hai implementato un design pattern in un progetto, puoi riutilizzarlo in altri progetti simili per risparmiare tempo e sforzi.
    5. Scalabilità: I design pattern aiutano a creare architetture software flessibili e scalabili. Le soluzioni modulari e ben progettate consentono di adattarsi facilmente ai cambiamenti nei requisiti e nell’ambiente circostante.
    6. Documentazione Implicita: L’uso di design pattern nel codice può fungere da documentazione implicita. Quando un programmatore esperto vede un design pattern, capisce immediatamente l’intento e la struttura del codice.
    7. Sviluppo Collaborativo: L’adozione di design pattern promuove un approccio collaborativo allo sviluppo. I membri del team possono contribuire in modo coerente e costruttivo, poiché seguono uno schema ben definito.
    8. Migliori Pratiche: I design pattern incorporano best practice nell’ambito del design e dello sviluppo del software. Questo aiuta i programmatori a evitare errori comuni e a creare codice di alta qualità.

    In generale, i design pattern sono strumenti potenti per migliorare la qualità, la manutenibilità e la riusabilità del codice. Tuttavia, è importante utilizzarli con discernimento e adattarli alle esigenze specifiche di ogni progetto, evitando l’eccessiva complessità o la sovrapplicazione di pattern.

    I design pattern sono spesso presentati come modelli di comunicazione tra i membri di un team di sviluppo. Essi possono aiutare a comunicare idee complesse in modo più chiaro e consentire a un team di adottare un approccio comune alla risoluzione dei problemi.

    Esistono molti tipi diversi di design pattern, che possono essere raggruppati in diverse categorie. Ecco alcune categorie di design pattern comuni:

    1. Creational Patterns (Pattern Creazionali): Questi pattern si concentrano sul processo di creazione delle istanze degli oggetti. Esempi includono Singleton, Factory Method, Abstract Factory, Builder e Prototype.
    2. Structural Patterns (Pattern Strutturali): Questi pattern riguardano la composizione delle classi e degli oggetti in strutture più grandi. Esempi includono Adapter, Bridge, Composite, Decorator, Facade e Proxy.
    3. Behavioral Patterns (Pattern Comportamentali): Questi pattern gestiscono le interazioni tra oggetti e il flusso di controllo. Esempi includono Observer, Strategy, Command, State, Template Method e Visitor.
    4. Concurrency Patterns (Pattern di Concorrenza): Questi pattern affrontano problemi legati alla gestione della concorrenza e della parallelizzazione nel software. Esempi includono Mutex, Semaphore, Reader-Writer Lock, e altri pattern legati alla programmazione concorrente.
    5. Architectural Patterns (Pattern Architetturali): Questi pattern riguardano l’organizzazione generale di un’applicazione e delle sue componenti. Esempi includono MVC (Model-View-Controller), MVVM (Model-View-ViewModel), e altri pattern architetturali.

    I design pattern non sono codice completo da copiare e incollare, ma piuttosto linee guida e concetti che possono essere adattati alle esigenze specifiche di un progetto. L’uso dei design pattern può migliorare l’organizzazione del codice, promuovere la riusabilità e semplificare la manutenzione nel lungo termine. Foto di Santiago Boada: https://www.pexels.com/it-it/foto/modello-parete-vintage-design-17847521/

  • Come ripulire gli input dell’utente in un form HTML in PHP (GUIDA)

    Come ripulire gli input dell’utente in un form HTML in PHP (GUIDA)

    In questo tutorial vedremo le più comuni pratiche di programmazione per rendere più sicuri i nostri siti ed applicazioni PHP.

    Sanitizzare è un termine poco familiare ai più, eppure viene spesso associato ad una pratica di sicurezza informatica, da attuarsi in fase di programmazione, decisamente trascurata. Si tratta di verificare mediante opportuni check lato codice che l’input inserito dall’utente di internet, specialmente se anonimo, sia idoneo ad essere dato in pasto al codice dell’applicazione web.

    sanitizzante, anche come agg. e s. m., detto di quelle sostanze ad azione battericida che riducono il numero di batteri o di virus, spec. in ambienti e macchinari destinati alla lavorazione di prodotti alimentari.

    (treccani.it)

    L’argomento è tanto vasto quanto complesso, e questo articolo cercherà  di coprire gli aspetti più essenziali: la prima cosa che possiamo dire è che l’approccio di base alla programmazione è molto importante. In particolare, si tratta di fare in modo di garantire che il codice che andremo ad eseguire sia coerente con la configurazione del server, e che soprattutto non ci siano:

    • servizi inutilizzati in esecuzione;
    • operazioni inutili all’interno del codice.

    Solo in questo modo si potrà  mantenere il codice snello e manutenibile nel tempo, con ovvi vantaggi in termini di sicurezza.

    Se ad esempio il dato in ingresso viene acquisito mediante una variabile:

    $x = $_POST['abc']

    oppure

    $x = $_GET['abc']

    è indispensabile verificare la natura dell’input. In altri termini, mediante espressioni regolari (REGEX) potremo fare in modo di assicurarci che quell’input sia effettivamente quello che ci aspettiamo e non, ad esempio, un frammento di codice malevolo (XSS) o un tentativo di SQL poisoning.

    Ad esempio se $x deve essere una mail, potremmo premettere a qualsiasi altra istruzione:

    if ( preg_match('/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$/',$x) ) {
    //istruzioni specifiche
    //[...]
    }
    else {
    //tratta l'abuso, o ignoralo
    //[...
    }
    

    L’esempio non è la migliore regex al mondo per validare una mail, ma rende l’idea di due cose molto importanti:

    1. le validazioni degli input vanno eseguite in modo specifico caso per caso, e richiedono spesso uno sforzo concettuale notevole;
    2. non esiste una regex assolutamente adatta a filtrare qualsiasi input, dipende sempre dal contesto.

    Altra cosa importante, una sanitarizzazione / validazione robusta degli input va eseguita sempre lato server, in quando via Javascript è necessaria per facilitare la vita all’utente ma, al tempo stesso, è facilmente aggirabile da un attaccante.

    Premesso ciò, un possibile approccio permette di suddividere la sanitarizzazione dell’input utente – ad esempio, una casella di ricerca nel sito ($_POST) oppure un parametro URL ($_GET) in questo modo:

    1. le richieste via GET si possono trattare basilarmente mediante urlencode.
    2. il filtro di codice HTML/via GET avviene mediante htmlentities.
    3. per evitare l’uso improprio dei comandi della shell via remoto, sfruttare escapeshellcmd;
    4. per passare/limitare gli argomenti via shell: use escapeshellargs.
    5. per filtrare un parametro in una query MySQL sfruttare mysql_real_escape_string.
    6. in molte situazioni è opportuno validare l’input ragionando sulla sua forma tipica ed inserendo dei blocchi “if” che ne testino lunghezza, struttura e via dicendo (REGEX)

    Esempi pratici d’uso:

    echo '';
    $href = htmlEntities($_GET['abc'], ENT_QUOTES);
    $escaped_command = escapeshellcmd($command);
    system('ls '.escapeshellarg($dir));
    $myinput = mysql_real_escape_string($myinput);

    Photo by Zayabibu

  • Come filtrare le variabili di ingresso con PHP

    Come filtrare le variabili di ingresso con PHP

    L’utilizzo di PHP prevede svariate funzioni di basso livello che, in molti casi, è bene trovarsi pronti a trattare con le dovute cautele per evitare rischi di attacco da parte di utenti maliziosi che manipolino l’output.

    (c) leremy – Fotolia.com

    La situazione tipica di questi casi riguarda una sottovalutazione globale del problema, salvo poi doversi ricredere quando il nostro sito è compromesso (spesso definitivamente); non ci sono dubbi, in effetti, che il rischio della manipolazione delle variabili di ingresso (form di ingresso e, naturalmente, variabili che passiamo mediante concatenazione direttamente nell’URL) inserite direttamente dagli utenti (a volte addirittura anonimi) sia un fattore da non prendere sottogamba per nessuna ragione.

    Per questo motivo è necessario filtrare le variabili di ingresso, e questo significa concentrare la propria attenzione su quello che potenzialmente potrebbe arrivare al nostro codice mediante $_POST e $_GET.

    Per filtrare una variabile di ingresso si utilizza normalmente addslashes, e filtrare le due variabili in questione (e tutte le loro occorrenze nel codice del sito, ovviamente) significa fare qualcosa di questo tipo:

    $_POST['qualcosa'] = addslashes( $_POST['qualcosa'] );
    
    $_GET['qualcosa'] = addslashes( $_GET['qualcosa'] );

    Per la cronaca, comunque, la funzione “magic quotes” serve esattamente ad assolvere questo tipo di funzionalità , imponendo l’utilizzo automatico di addslashes su tutti i GET/POST e, in aggiunta, su quello che viene usualmente salvato nei cookie. Per attivarlo, in condizioni di amministratore del sistema con il massimo dei privilegi, sarà  necessario aggiungere:

    php_flag magic_quotes_gpc on

    nel file .htaccess, oppure possiamo operare sul PHP.ini (quando consentito):

    magic_quotes_gpc = on

    In caso di difficoltà  è necessario contattare l’hosting che state utilizzando perchè risolvano il problema loro (e non è detto, in generale, che lo facciano, specie sulle soluzioni ultra-low cost ed in overselling). Ci sono altre regole generali di sicurezza da seguire, come ad esempio disattivare la notifica esplicita degli errori in PHP, relegando il tutto ad un log di sistema che possiamo leggere soltanto noi e privando potenziali attaccanti, in questo modo, di informazioni che potrebbero contribuire ad una code injection o SQL injection.

  • Costanti, variabili ed operatori PHP: cosa sono e come funzionano (GUIDA)

    Costanti, variabili ed operatori PHP: cosa sono e come funzionano (GUIDA)

    Oggi vedremo come si usano le basi del linguaggio PHP, ovvero: Costanti, variabili ed operatori.

    Cos’è una variabile

    Una variabile, formalmente parlando, in informatica non è altro se non una zona di memoria: in particolare, si tratta di una zona di memoria che può essere allocata per contenere un dato – nel caso più semplice, un numero binario. Per via di particolari processi di codifica, poi, una variabile può contenere anche una stringa, un numero intero, un booleano vero/falso e così via. L’uso delle variabili è utile per effettuare operazioni matematiche (somme, sottrazioni, divisioni, moltiplicazioni) ma anche per memorizzare un valore, lavorarci e restituirlo all’utente in forma elaborata.

    Costanti in PHP

    In PHP esistono sia costanti che variabili, e la loro differenza è lapidaria: le costanti hanno valore fisso, prefissato dall’inizio, mentre le variabili possono cambiare in modo dinamico. In PHP una variabile viene dichiarata utilizzato la funzione define, che prende due parametri, nell’ordine: il primo è il nome della variabile, messo tra virgolette e solitamente tutto in maiuscolo, mentre il secondo rappresenta il valore che quella costante dovrà  assumere.

    Ecco un esempio di definizione di due costanti, PIPPHOUSE e TOPOLIGNO, che assumono valore di un numero intero come stringa e di un numero intero. Ovviamente il valore poteva essere anche una stringa di lettere e/o numeri, un booleano, e così via.

    define(‘PIPPHOUSE’, ‘1285351623576125765’);
    define(‘TOPOLIGNO’, 5);

    Per richiamare all’interno del codice una variabile, poi, basta riportare il nome della costante senza virgolette, quindi ad esempio usarla come valore da assegnare (lato destro):

    $pippo = TOPOLIGNO;

    echo $pippo; //stampa a video il valore 5, come impostato prima

    Esistono, e sono davvero molto comode da utilizzare, anche le costanti predefinite di PHP, che sono già  impostate nel linguaggio e pronte all’uso: quelle che seguono sono le due più importanti e che si usano più spesso nella programmazione di ogni giorno.

    • __FILE__Restituisce il path della cartella in cui stiamo eseguendo il codice dello script.
    • __DIR__ Restituisce, similmente, il path della directory in cui è contenuto il file che stiamo eseguendo.

    Variabili in PHP

    Per chi provenisse da altri linguaggi di programmazione, PHP presenta una differenza fondamentale: NON è un linguaggio fortemente tipizzato, ovvero non è necessario specificare il tipo di una variabile prima di dichiararla (ad esempio string o integer). Questo significa che ci sarà  una maggiore flessibilità  nel linguaggio e che, soprattutto, non sarà  necessario assegnare da prima o imporre un tipo per una variabile. A differenza di quello che succede con linguaggi fortemente tipizzati come Java, pertanto, posso assegnare una variabile direttamente senza specificare nulla:

    $nome = “pippo”;

    $numero = 123.45;

    $flag = false;

    In realtà  possiamo fare anche meglio di così, perchè è possibile assegnare ad una variabile il risultato di un’espressione, ad esempio:

    $flag1 = true;

    $flag2 = false;

    $numero_due = 1+1;

    $flag = ($flag1 && $flag2); //avrà  valore false

    Operatori

    Gli operatori servono a combinare il valore di più variabili, e si possono utilizzare in vari modi: ad esempio per concatenare o mettere una di seguito all’altra due stringhe:

    $nome= “James”;

    $cognome = “hetfield”;

    $nome_completo = $nome + ” ” +$cognome;

    Il risultato sarà  quindi il nome e cognome del cantante dei Metallica, separato da uno spazio ” ” che abbiamo concatenato come stringa con lo spazio tra virgolette. Ci sono anche operatori logici, poi, come AND e OR, che si richiamano a quelli usati nella logica matematica:

    ($condizione1 && $condizione2); // vale true solo se entrambe sono true

    ($condizione1 || $condizione2); // vale true solo se almeno una è true

    In genere è sempre preferibile mettere qualsiasi operatore nelle espressioni su riportate tra parentesi tonde, per evitare problemi di leggibilità  del codice.