You are here

Guide

Tutorial Addestramento IA: esempio di fine-tuning di TinyLlama per NL→Bash

Un proof-of-concept per “demitizzare” la magia dietro il machine learning.

Con questo tutorial voglio accompagnarti passo-passo alla creazione di un assistente IA per la scrittura di comandi Bash, assumendo che tu sappia già muoverti in Linux ma non abbia mai messo mano a Hugging Face o al fine-tuning. L’obiettivo è demitizzare: vedere che dietro l’apparente magia dell'IA c’è una pipeline fatta di comandi Bash, qualche script Python e tanta pazienza.

Proof-of-concept – Alla fine otterremo un modello (“TinyBash”) che a volte sa proporre comandi ragionevoli. Non è pronto per la produzione: il dataset è piccolo e il training brevissimo. Ma noteremo comunque il salto da risposte totalmente casuali a output che cominciano ad assomigliare a Bash.

Per esser chiari fin da subito... funziona?

1. Dimensioni e disparità di scala
TinyBash parte da TinyLlama-1.1 B (≈1,1 mld di parametri), che con la quantizzazione a 4-bit occupa 0,4 GB e allena solo ~7 MB di delta-LoRA. Anche il più piccolo Code Llama 7 B è già 6 volte più grande; le varianti da 13 B, 34 B e 70 B arrivano a 12 volte, 31 volte e ≈64 volte i parametri di TinyBash. I modelli proprietari di casa OpenAI — ChatGPT Codex (codex-1) e ChatGPT o3 — non rivelano la taglia, ma le stime parlano di centinaia di miliardi → oltre 150-200 volte rispetto al nostro prototipo. Ne derivano reti con memoria di lungo contesto, ragionamento di livello superiore e, soprattutto, output di codice molto più affidabili.
 

2. Cosa cambia con più hardware
Su una GPU modesta (4 GB) usiamo batch 2, LoRA r=8 e 2 epoche: abbastanza per “vedere” il processo. Con 16 GB di VRAM puoi portare il batch a 4, raddoppiare r, togliere la quantizzazione o salire a 8-bit, aggiungere scheduler di LR-decay e spingere a 5-10 epoche. Su A100/H100, le big-tech ri-addestrano il modello intero in FP16/BF16, applicano RLHF o RLAIF e orchestrano tutto con pipeline MLOps automatizzate; il flusso concettuale è lo stesso, cambiano solo scala e controlli.

3. Considerazioni sui dati
Noi usiamo il corpus di addestramento NL2Bash pubblicato dall’Università di Washington nella ricerca scientifica "NL2Bash: A Corpus and Semantic Parser for Natural Language Interface to the Linux Operating System" (vedi PDF). Esso conta 9 305 coppie NL → Bash (di cui 8090 nel training set), copre 102 utility Bash e 206 flag — materiale di qualità, ma pur sempre sei ordini di grandezza in meno (cioè milioni di volte più piccolo) rispetto ai miliardi di token di codice usati da Code Llama o Codex. Riguardo alla qualità del corpus di addestramento, misurata a campione, sta attorno all’85%, quindi gli errori presenti sono comunque pochi rispetto alle oltre novemila coppie totali.

4. Aspettative realistiche
Nella ricerca su NL2Bash, l’Università di Washington ha usato un modello sequence-to-sequence con meccanismo di copia (ST-CopyNet): l’encoder legge la domanda in inglese, il decoder RNN genera il comando e può copiarne parti (file, pattern) direttamente dall’input; sui 606 esempi del test set – mai visti a training – questo modello ha azzeccato la struttura nel 49% dei casi e il comando completo nel 36%, pur disponendo di 9 305 coppie NL→Bash (8 090 di train). TinyBash, invece, parte da TinyLlama-1.1 B (1,1 mld di parametri) e ritocca solo 7 MB di delta-LoRA quantizzati a 4 bit: è un’architettura diversa, molto più grande ma anche compressa, quindi quel 36 % non è un tetto; l’unico raffronto corretto sarebbe far girare TinyBash sullo stesso test set, dove il risultato dipenderà da batch, learning-rate, epoche, rango LoRA e altri iper-parametri di fine-tuning. Nel nostro run di prova, su quattro prompt mostrati a fine tutorial TinyBash centra bene 1-2 risposte su 4 (ad es. “List all open TCP ports” è giusta, “Show total RAM” è sbagliata): numeri coerenti con la difficoltà del compito e adeguati a un prototipo didattico che serve a illustrare il processo, non a sostituire uno strumento di produzione.

5. Quindi… funziona?
Come demo didattica, sì: dopo 2 epoche TinyBash passa da output casuali a comandi spesso plausibili, mostrando passo-passo la pipeline reale di un fine-tuning. Ma un 1,1 B a 4-bit resta fragile: errori di sintassi, flag inventati e “allucinazioni” sono frequenti. Per applicazioni reali in ambienti di produzione servono modelli grandi, molti più dati e rigorosi controlli. In altre parole, la magia è identica, scala e budget no — e questo tutorial ti fa toccare con mano il meccanismo prima di affrontare mostri da cento miliardi di parametri...

Per il testing, ho usato:

Component Dettaglio
OS Linux Mint 22 “Virginia” (kernel 6.8)
GPU NVIDIA GeForce GTX 1050 (4 GiB VRAM, arch 6.1 “Pascal”)
RAM 16 GB
Driver nvidia-driver 535 + CUDA 12.0.140
Python 3.12.3 (in venv)

Prima di cominciare, ti propongo un breve glossario tecnico essenziale:

  • Modello (Model)
    È l’insieme di parametri numerici (pesi + bias) e istruzioni matematiche che trasformano un input (per esempio una frase) in un output (per esempio un comando Bash). Un modello rappresenta matematicamente una rete neurale artificiale: i parametri sono i “numeri liberi” che il training può ottimizzare. Quando diciamo TinyLlama 1.1 B indichiamo proprio che il modello contiene circa 1,1 miliardi di parametri. In questo tutorial partiamo da tale modello di base e creiamo una variante fine-tuned chiamata TinyBash.

  • Pesi (Weights)
    I valori — solitamente nell’ordine dei miliardi — che il modello apprende durante l’addestramento. Determinano “che cosa ha imparato” e vengono salvati in file binari. Possiamo immaginarli come la “forza” delle sinapsi fra i neuroni artificiali: ogni peso stabilisce quanto l’attivazione di un neurone influenzi quello successivo nella rete. (I bias sono parametri speciali che spostano le attivazioni, ma rientrano anch’essi nel conteggio totale dei parametri.)

  • Fine-tuning
    Operazione con cui si ri-allena un modello pre-esistente su un nuovo insieme di dati per specializzarlo in un compito (nel nostro caso, NL → Bash). Il ri-addestramento avviene per un numero limitato di epoche: un’epoca corrisponde a un passaggio completo dell’intero dataset attraverso il modello (forward + back-propagation su ogni esempio). Più epoche significano più opportunità di apprendere, ma anche maggior rischio di overfitting. In questo tutorial useremo 2 epoche, sufficienti a dimostrare il processo senza richiedere tempi di calcolo eccessivi.

  • LoRA (Low-Rank Adaptation)
    Tecnica di Parameter-Efficient Fine-Tuning: invece di riscrivere tutti i pesi, aggiunge piccole matrici “delta” (rank basso) che si sommano al modello base. Riduce VRAM, tempo e storage — nel nostro script alleniamo appena ~7 MB di parametri.

  • Quantizzazione (Quantize)
    Conversione dei pesi da 16 / 32 bit a formati a bassa precisione (8-, 4-, o 2-bit) per risparmiare memoria e accelerare l’inferenza — cioè la fase in cui il modello, già addestrato, viene eseguito per generare una risposta a un nuovo input. In pratica, l’inferenza è l’uso del modello “in produzione”, distinto dal training. Con la quantizzazione a 4 bit che noi useremo, il footprint di TinyLlama scende da ~4 GB a ~0,4 GB, rendendo più veloce (e possibile su hardware modesto) il calcolo delle risposte.

  • GGUF
    Contenitore binario della famiglia GGML pensato per modelli quantizzati; include pesi, tokenizer e metadati. Ollama (e molte altre tool-chain) lo carica in un’unica syscall.

  • Tokenizer
    Modulo che segmenta il testo in unità (“token”) comprensibili al modello. Per TinyLlama è basato su SentencePiece; lo usiamo anche quando esportiamo in GGUF.

  • Dataset
    Collezione di esempi di addestramento. Qui utilizziamo NL2Bash e lo trasformiamo in stile Alpaca.

  • Alpaca template
    Formato di prompt a tre ruoli (<|system|>, <|user|>, <|assistant|>) introdotto dall’esperimento Stanford Alpaca. Mantenerlo identico tra training e inferenza assicura coerenza nelle risposte.

Ci sarebbero molti altri termini da spiegare nel dettaglio per comprendere il codice che useremo, ma non ci addentreremo nelle spiegazioni teoriche. Il nostro focus è solo su del codice pronto per essere testato. Detto ciò, installiamo questi pacchetti:

sudo apt update
sudo apt install build-essential git python3-venv cmake wget curl unzip pkg-config libcurl4-openssl-dev zlib1g-dev libopenblas-dev libomp-dev

Ollama è un runtime leggerissimo che esegue modelli quantizzati in formato GGUF:

curl -fsSL https://ollama.com/install.sh | sh

Prepariamo un virtual-env così non sporchiamo il sistema:

python3 -m venv ~/llm_env
source ~/llm_env/bin/activate
pip install --upgrade pip
pip install unsloth bitsandbytes transformers peft datasets accelerate sentencepiece

Il primo script usa unsloth per caricare e quantizzare al volo il modello base.

Creiamo il file download.py, rendiamolo eseguibile e lanciamolo:

#!/usr/bin/env python3
from unsloth import FastLanguageModel
model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
model, tokenizer = FastLanguageModel.from_pretrained(
        model_name = model_name,
        device_map = "auto",
        load_in_4bit = True,
)

Quando lo script termina, i pesi sono già a disposizione del training e non dobbiamo riscaricarli.

Useremo il dataset "NL2Bash: A Corpus and Semantic Parser for Natural Language Interface to the Linux Operating System", pubblicato nel 2018 da Xi Victoria Lin, Chenglong Wang, Luke Zettlemoyer, and Michael D. Ernst. Questi dati di addestramento sono composti di 8090 coppie di English NL (Natural Language) → Bash

Il formato originale però non è adatto a un modello conversazionale, quindi lo riscriviamo in stile Alpaca: system / user / assistant.

Creiamo e lanciamo nl2bash_alpaca.py:

#!/usr/bin/env python3
from datasets import load_dataset
ds = load_dataset("jiacheng-ye/nl2bash", split="train")
# uniforma in stile Alpaca
def to_alpaca(example):
    return {
        "instruction":  example["nl"],
        "output":       example["bash"],
        "system":       "Return ONLY valid Bash, no prose."
    }
alpaca_ds = ds.map(to_alpaca).shuffle(seed=42)
alpaca_ds.save_to_disk("nl2bash_alpaca")

Siamo arrivati alla parte più impegnativa. Creiamo e lanciamo train_tinybash.py per eseguire l'addestramento. Assicuriamoci che il nostro computer abbia una ventilazione efficiente, perché lavorerà al massimo per alcune ore. E' una buona idea anche monitorare la temperatura interna di CPU e GPU:

#!/usr/bin/env python

import torch, json, os
from unsloth import FastLanguageModel
from unsloth.chat_templates import get_chat_template
from trl import SFTTrainer
from transformers import TrainingArguments, DataCollatorForSeq2Seq
from datasets import load_from_disk

# ── Parametri principali ──────────────────────────────────────────────────────
MODEL_NAME   = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
MAX_LEN      = 2048
BATCH        = 2                 # con 4 GB VRAM
GRAD_ACC     = 8                 # → eff. batch 16
LR           = 5e-5
EPOCHS       = 2
OUT_DIR      = "tinybash_lora"
GGUF_DIR     = "tinybash_gguf"
QUANT_METHOD = "q4_k_m"          # migliore trade-off CPU

# ── 1. Carica il modello base in 4-bit ────────────────────────────────────────
model, tok = FastLanguageModel.from_pretrained(
        model_name       = MODEL_NAME,
        max_seq_length   = MAX_LEN,
        load_in_4bit     = True,
        device_map       = "auto",
)

# 1-bis. APPLICA IL TEMPLATE CON {SYSTEM}
tok = get_chat_template(
        tok,
        chat_template = "alpaca",   # oppure il tuo template custom
        map_eos_token = True)       # allinea l’EOS

# ── 1-ter. Funzione che combina system, instruction, output ────────────────
def format_unsloth(example):
    """
    Converte *N* righe del batch in *N* prompt formattati.
    Se il dataset chiama la funzione su una sola riga (liste lunghe 1)
    funziona lo stesso.
    """
    bos = tok.bos_token or ""
    eos = tok.eos_token or ""

    # example["instruction"] è una lista di lunghezza batch_size
    formatted_batch = []
    for sys, inst, outp in zip(example["system"],
                               example["instruction"],
                               example["output"]):
        formatted_batch.append(
            f"{bos}<|system|>\n{sys}{eos}"
            f"<|user|>\n{inst}{eos}"
            f"<|assistant|>\n{outp}{eos}"
        )
    return formatted_batch          # 🔸 stessa lunghezza del batch


# ── 2. Configura LoRA minimalista ─────────────────────────────────────────────
model = FastLanguageModel.get_peft_model(
    model,
    r               = 8,
    target_modules  = ["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha      = 16,
    lora_dropout    = 0,
    bias            = "none",           # opzionale
    use_gradient_checkpointing = "unsloth",
    random_state    = 42,
    max_seq_length  = MAX_LEN,
)

# ── 3. Dataset già preparato (vedi Parte 1) ───────────────────────────────────
data = load_from_disk("nl2bash_alpaca")  

# ── 4. Iper-parametri Trainer ────────────────────────────────────────────────
args = TrainingArguments(
        output_dir                      = OUT_DIR,
        per_device_train_batch_size     = BATCH,
        gradient_accumulation_steps     = GRAD_ACC,
        learning_rate                   = LR,
        num_train_epochs                = EPOCHS,
        logging_steps                   = 20,
        save_strategy                   = "epoch",
        bf16                            = False,     # NVIDIA GeForce GTX 1050 non supporta BF16
        fp16                            = True,      # usa FP16, va bene su Pascal
)

trainer = SFTTrainer(
        model               = model,
        train_dataset       = data,
        tokenizer           = tok,
        data_collator       = DataCollatorForSeq2Seq(tok),
        max_seq_length      = MAX_LEN,
        args                = args,
        formatting_func     = format_unsloth,
)

trainer.train()

Tempo di training – sulla GTX 1050 servono ~3 h per due epoche.

Dopo l’allenamento, i pesi LoRA sono in tinybash_lora/checkpoint-NNNN. Dobbiamo usare il valore NNNN più grande.

Questo è il file merge_and_export.py, con il quale generiamo il modello addestrato in tinybash_gguf/unsloth.Q4_K_M.gguf:

#!/usr/bin/env python3
from pathlib import Path
from unsloth import FastLanguageModel
from unsloth.chat_templates import get_chat_template
from peft import PeftModel

MODEL_NAME = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
OUT_DIR    = Path(__file__).parent / "tinybash_lora/checkpoint-1010"          # path locale
GGUF_DIR   = "tinybash_gguf"
QUANT      = "q4_k_m"

print("🔹 Carico base 4-bit…")
model, tok = FastLanguageModel.from_pretrained(
    model_name     = MODEL_NAME,
    load_in_4bit   = True,
    device_map     = "auto",
    max_seq_length = 2048,
)
tok = get_chat_template(tok, chat_template="alpaca", map_eos_token=True)

print("🔹 Carico adapter LoRA…")
model = PeftModel.from_pretrained(
    model, str(OUT_DIR), local_files_only=True
)

print("🔹 Salvo GGUF fuso…")
model.save_pretrained_gguf(
    GGUF_DIR, tok, quantization_method=QUANT
)
print("GGUF creato in", Path(GGUF_DIR).resolve())

Creiamo la cartella model per ollama:

mkdir model
cd model
cp ../tinybash_gguf/unsloth.Q4_K_M.gguf ./tinybash.q4_k_m.gguf

Questo è il file Modelfile da mettere dentro la cartella model:

# Modelfile
FROM ./tinybash.q4_k_m.gguf

# risposta secca e ripetibile
PARAMETER temperature 0.1
PARAMETER stop "</s>"

TEMPLATE """{{ if .System }}{{ .System }}

{{ end }}### Instruction:
{{ .Prompt }}

### Response:
{{ .Response }}</s>
"""

SYSTEM "You are TinyBash. Return ONLY valid Bash commands or short shell scripts, with no extra commentary."

Infine, registriamo il modello con ollama:

ollama rm tinybash # Opzionale, serve per rimuovere il modello se già precedentemente creato
ollama create tinybash -f Modelfile

Creiamo il file /usr/local/bin/tinybash: che fa da wrapper:

#!/usr/bin/env bash

# tinybash: wrapper per ollama run tinybash
# Usage: tinybash <prompt…>

if [ $# -eq 0 ]; then
  echo "Usage: tinybash <prompt…>"
  exit 1
fi

prompt="$*"
echo "$prompt" | ollama run tinybash

Ora verifichiamo la differenza fra TinyLlama base e TinyBash addestrato:

$ PROMPT="List the 10 largest files in the current directory"
$ echo "$PROMPT" | ollama run tinyllama
Here is a list of the 10 largest files in the current directory as of this writing:

1. "C:\Users\USER\Desktop\file1.txt" - 37 MB (2022-08-24)
2. "C:\Users\USER\AppData\Roaming\Python\Python310\site-packages\mypackage\__init__.py" - 58 MB (2022-08-29)
3. "C:\Users\USER\Downloads\file2.txt" - 67 MB (2022-08-24)
4. "C:\Users\USER\Documents\folder1\file3.pdf" - 73 MB (2022-08-25)
5. "C:\Program Files\notepad++\plugins\pugjawoo\PugJawOO.dll" - 96 MB (2022-08-24)
6. "C:\Users\USER\Desktop\folder2\file4.docx" - 113 MB (2022-08-25)
7. "C:\Program Files\Notepad++\plugins\pugjawoo\PugJawOO.dll" - 119 MB (2022-08-24)
8. "C:\Users\USER\Downloads\folder3\file5.docx" - 147 MB (2022-08-26)
9. "C:\Users\USER\AppData\Roaming\Python\Python310\site-packages\mypackage\__init__.py" - 154 MB (2022-08-29)
10. "C:\Program Files\notepad++\plugins\pugjawoo\PugJawOO.dll" - 176 MB (2022-08-24)

Note that the size of each file may vary depending on its content and other factors such as encoding or compression methods used.

$ echo "$PROMPT" | ollama run tinybash
ls | sort -nr | head -n 10

Altri esempi:

Prompt TinyBash risponde
“List all open TCP ports” netstat -tlnp
“Show total RAM” (bug) “Total amount of RAM is 1024 MB”
“Add execute to permissions of all dirs in $HOME” chmod 755 ~/*

In questo modo, osserviamo che le risposte sono concettualmente più coerenti rispetto al modello base, ma la precisione è ancora bassa.

Il risultato non è production-ready, ma dimostra che la magia è in realtà un processo replicabile con gli strumenti giusti.

Per futuro riferimento, qui c'è una copia dei files che ho usato, comprensivi di tutto: TinyBash.zip. Questo zip contiene gli script Python e Bash del tutorial, il dataset NL2Bash già convertito in formato Alpaca, i checkpoint LoRA e il modello finale fuso in GGUF a 4-bit con il relativo Modelfile, la cartella “model” pronta per ollama create, l’intera tool-chain di llama.cpp nella versione testata, oltre a cache, tokenizer e configurazioni indispensabili per ricostruire l’esperimento anche offline. Ad ogni modo, se seguirai questo tutorial punto per punto, non avrai bisogno di scaricare alcun file dal mio blog

Buon hacking,
22 maggio 2025

Drupal 10 e PHP 8 per sviluppatori: architettura, moduli, temi e database

Così come ho precedentemente condiviso i miei appunti su Java, metto a disposizione anche i miei appunti su PHP 8 e Drupal 10.

Tieni a mente che questo testo può contenere errori o imprecisioni. Non ho risorse per fare una revisione accurata, che solitamente andrebbe affidata a terzi.

Link: https://www.informatica-libera.net/Drupal10.pdf

(22 febbraio 2025)

Restore the scrollbar in Firefox

Recent versions of Firefox no longer show the scrollbar. Or rather, they show it too fine and only when scrolling. From my point of view, this is an accessibility problem.

This is the solution I found to restore the scrollbar by changing some values in about:config:

layout.testing.overlay-scrollbars.always-visible -> true
widget.gtk.overlay-scrollbars.enabled -> false
widget.non-native-theme.scrollbar.size.override -> 20
widget.non-native-theme.scrollbar.style -> 3
widget.non-native-theme.win.scrollbar.use-system-size -> false
widget.non-native-theme.always-high-contrast -> true

After closing and reopening Firefox, I verified that the scrollbar reappeared in Firefox 133 on macOS and Linux. This solution should also work on Windows.

Of course, you can customize these values. This is a brief explanation:

layout.testing.overlay-scrollbars.always-visible -> true
This setting ensures that scrollbars are always visible, even when content is not actively being scrolled. It overrides the behavior where scrollbars only appear while scrolling.

widget.gtk.overlay-scrollbars.enabled -> false
On systems using GTK (commonly Linux distributions), this disables the use of overlay scrollbars, which are typically thinner and less obtrusive. By disabling this, Firefox will use the more traditional, always-visible scrollbars.

widget.non-native-theme.scrollbar.size.override -> 20
This value sets the width of the scrollbar in pixels, overriding the default size. I chose a value of 20 to make the scrollbar more prominent, improving visibility and usability. The right value for you will depend on your screen resolution.

widget.non-native-theme.scrollbar.style -> 3
This setting changes the appearance of the scrollbar. A value of 3 corresponds to a style that provides a more traditional and accessible design. This setting accepts integers from 0 to 5, with each number representing a different scrollbar style:

0: Default style. The appearance and behavior of the scrollbar depend on the non-native theme being used.
1: Minimalist style. The scrollbars are thinner and less intrusive.
2: Simple style. A basic scrollbar without advanced visual effects.
3: Traditional style. The scrollbar appears thicker with a classic look, similar to older implementations.
4: Transparent style. The scrollbar might only be partially visible or appear when the mouse hovers over it.
5: Advanced custom style. A rendering designed for enhanced visual appearance or integration with specific themes.

You can experiment with these values to determine which works best for your preferences.

widget.non-native-theme.win.scrollbar.use-system-size -> false
By default, Firefox on Windows uses the system-defined scrollbar size. Setting this to false allows the browser to apply the custom size specified in widget.non-native-theme.scrollbar.size.override.

widget.non-native-theme.always-high-contrast -> true
This forces the scrollbars to use a high-contrast theme, making them more visible against a variety of backgrounds. This is particularly useful for users with visual impairments or those who prefer a clearer visual separation between content and UI elements.

By tweaking these values, you can fully customize the appearance and behavior of scrollbars in Firefox to meet your accessibility and usability needs.

Happy hacking,
December 13, 2024

Dalle basi di Java ai microservizi con Spring Boot

«La conoscenza è come un fuoco: se non la alimenti condividendola, si spegne». Per questo motivo, condivido questi miei corposi appunti, che ho trasformato in un libro strutturato per agevolare l'apprendimento e la preparazione a colloqui di lavoro.

Per la pubblicazione mi affido al mio blog, anziché ad un libro stampato, perché l'uso di manuali cartacei è sempre più desueto tra noi programmatori, che solitamente cerchiamo e troviamo tutto online. Gli scaffali delle biblioteche e delle librerie sono ormai pieni di libri di informatica costosi, chiusi e impolverati, ma «un libro chiuso è solo carta».

Tieni a mente che questo testo può contenere errori o imprecisioni. Non ho risorse per fare una revisione accurata, che solitamente andrebbe affidata a terzi.

Che tu stia imparando Java per la prima volta, approfondendo la tua conoscenza per progetti avanzati o preparando un colloquio tecnico impegnativo, spero di darti una mano nel tuo studio.

Come risorsa aggiuntiva, può esserti utile "Java e UML - Corrispondenza Semantica tra Diagrammi di Classe e Codice Java".

Francesco Galgani, ultimo aggiornamento 30 dicembre 2024

Nota: La prima versione dei miei appunti su Java risale al 2006, questa versione arriva 18 anni dopo. Ti segnalo anche "Le mie attività di sviluppatore e di didattica del software" e il mio corso "Sviluppare app multipiattaforma con Codename One".

Da voce a testo, trascrizioni automatiche, dettatura con il cellulare

Esempio di dettatura, trascrizione automatica con un cellulare Android, con l'app "Golden Editor" (vedi video sottostante dimostrativo).
I sorgenti sono stati fatti da me con "Codename One", quindi compatibili con Android e iOS.

Golden Editor mantiene in memoria quello che scrivi, finché non lo cancelli: se chiudi e riapri l'app, quindi, il testo non va perduto.
Per condividere il testo, tieni premuto lo schermo per almeno tre secondi.

Apk: GoldenEditor-0.1.apk
Sorgenti multipiattaforma (adatti sia per Android sia per iOS): goldeneditor-sources-0.1.zip
Istruzioni per installare l'apk su Android: https://www.aranzulla.it/come-installare-apk-668919.html#chapter2

DOWNLOAD MP4

(1 giugno 2021)

Disassembly and reassembly ASUS ROG GL703VD-GC028T (Photos)

On Youtube you can find video tutorials related to models similar (like this), but not identical, to ASUS ROG GL703VD-GC028T

Here are some pictures of my assembly and reassembly. I think it's important to take notes, have at least five numbered boxes, and also have a full backup of your data... just in case something goes wrong.

You can click on each picture to enlarge it.

Installare Firefox ESR su Linux Mint e altre distro derivate da Ubuntu

Firefox ESR (Firefox Extended Support Release) è la versione più stabile di Firefox.

E' principalmente destinata ad aziende ed organizzazioni che necessitano di installare e mantenere Firefox su larga scala. Gli aggiornamenti di questa versione, infatti, non includono né nuove funzionalità né miglioramenti prestazionali, ma solo correzioni che risolvono problemi di sicurezza o altre vulnerabilità importanti. Questa versione di Firefox può essere gradita anche a chi, come me, desidera un ambiente di lavoro il più stabile possibile.

Nello specifico, attualmente Mozilla offre due diversi canali per gli aggiornamenti di Firefox: aggiornamento rapido e aggiornamento a supporto esteso (Extended Support Release o ESR).

  • Canale di aggiornamento rapido: riceve aggiornamenti importanti ogni sei settimane e, se necessari, aggiornamenti minori (come correzioni alla sicurezza e alla stabilità) entro questo ciclo di sei settimane.
  • Canale ESR: riceve aggiornamenti importanti all'incirca ogni quarantadue settimane e aggiornamenti minori (come correzioni alla sicurezza e alla stabilità e aggiornamento dei criteri) se necessari, ma comunque almeno una volta ogni sei settimane.

Firefox ESR è già inclusa di default in distribuzioni come NetRunner (che deriva da Debian).

Vediamo come installare Firefox ESR in una distribuzione derivata da Ubuntu come Linux Mint, che di default include la versione ad aggiornamento rapido di Firefox.

Per prima cosa salvati i segnalibri (e altra informazione importante memorizzata in Firefox, perché il tuo attuale profilo utente di Firefox potrebbe essere perso in questi passaggi), chiudi Firefox e dai da terminale questi tre comandi:

sudo add-apt-repository ppa:mozillateam/ppa
sudo apt-get update
sudo apt install firefox-esr

Fatto ciò, il tuo attuale Firefox e Firefox-ESR coesistono. Per avviare Firefox ESR invece del solito Firefox, devi cliccare con il destro sull'icona per avviare Firefox e cambiare il comando di avvio da:

firefox %u

a

firefox-esr %u

Fatto ciò, puoi installarti la lingua italiana da qui:
https://addons.mozilla.org/it/firefox/addon/italiano-it-language-pack/
(La lingua sarà caricata dopo averla installata e poi chiuso e riaperto Firefox)

Puoi installare il blocco delle pubblicità da qui:
https://addons.mozilla.org/it/firefox/addon/ublock-origin/?src=search
(Nota: su siti specifici, in caso di bisogno, il blocco delle pubblicità può essere disabilitato)

Io uso anche questa estensione per dare un minimo di privacy:
https://addons.mozilla.org/it/firefox/addon/privacy-badger17/?src=search

Infine importa i tuoi preferiti e fai le eventuali personalizzazioni che vuoi.

Se fin qui è tutto ok, apri il Gestore Pacchetti rimuovendo "firefox" e lasciando soltanto "firefox-esr", in modo da avere un'unica versione installata.

Francesco Galgani,
4 settembre 2019

How to install Oracle Java8 JDK 8u211 / 8u212 or later on Debian / Ubuntu / Linux Mint from deb

If you have trouble following these instructions, you can download the deb file I made from here:
https://www.informatica-libera.net/files/oracle-java8-jdk_8u231_amd64.deb.


At the moment, there is no working PPA to automatically download and install Oracle Java8 JDK 8u211 or 8u212 or later on Debian / Ubuntu / Linux Mint, because it's strictly necessary to manually download the jdk-8u211-linux-x64.tar.gz or jdk-8u212-linux-x64.tar.gz file from the Oracle site, after logging in:
https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

You can transform the jdk-8u212-linux-x64.tar.gz in oracle-java8-jdk_8u212_amd64.deb using make-jpkg provided by java-package.

So, remove any other Java version previously installed from the discontinued Java8 PPA (sudo apt-get remove oracle-java8-installer) then:

  1. sudo apt-get install java-package
  2. make-jpkg jdk-8u212-linux-x64.tar.gz
  3. sudo dpkg -i oracle-java8-jdk_8u212_amd64.deb (or any graphical installer opened by a double click on the deb, like gdebi-gtk)
  4. sudo apt-get -f install (to install missing dependencies)

That's all! :-)

Java 8 installation on Debian / Ubuntu / Linux Mint

Java 8 installation on Debian / Ubuntu / Linux Mint

Francesco Galgani,
30 April 2019

Aruba Cloud VPS - Allargare disco LVM, istruzioni [AGGIORNATO]

Problema generale: questa versione aggiornata dell'articolo propone due soluzioni per un unico problema, ovvero allargare lo spazio su un disco LVM (ovvero ripartizionarlo), accessibile soltanto tramite SSH, su cui gira Linux e alla seguenti condizioni: la partizione logica LVM non può essere smontata (perché su di essa gira il server), né può essere smontata alcuna delle partizioni fisiche che fanno parte dell'LVM.

Caso d'uso specifico: Sebbene Aruba Cloud, nel pannello di amministrazione dei Cloud Server Smart, permetta di fare un upgrade del server, passando ad esempio da Aruba Cloud Server Smart SMALL (20GB) ad Aruba Cloud Server Smart MEDIUM (40GB) o tagli più grandi come LARGE (80GB) o EXTRA LARGE (160GB), non fornisce però alcuna modalità automatica per ridimensionare il disco in modo sicuro. Più precisamente, facendo un upgrade del server, viene aumentato lo spazio disponibile su disco ma non vengono modificate le partizioni preesistenti.

Può Aruba ripartizionare il disco LVM in modo da usare tutto lo spazio disponibile, evitando di obbligare noi sviluppatori o sistemisti a fare a mano tale operazione, con tutti i rischi conseguenti? Ho fatto esplicitamente ad Aruba questa domanda. Ecco la poco incoraggiante risposta: «Possiamo procedere all'espansione del disco (LVM) qualora le condizioni del server lo consentano. Non possiamo garantire che l'intervento sia risolutivo. Verranno calcolate Euro 100,00 che includono le prime 2 ore. Nel caso in cui l'intervento dovesse protrarsi oltre verranno calcolate ulteriori Euro 50,00 per ogni ora aggiuntiva.»

Stando così le cose, e dopo aver dedicato ore e ore a leggermi documentazione disponibile in Rete, ho trovato due strade per affrontare e risolvere il problema di allargare il disco LVM al massimo spazio disponibile su disco.

Disclaimer: Ho provato le due soluzioni seguenti, a mio rischio e pericolo, su un mio server Aruba VPS su cui gira Ubuntu Linux 14.04. Tali passaggi, nel mio caso, hanno funzionato alla grande senza alcun problema. Presumo che gli stessi passaggi funzionino anche con altre distribuzioni Linux, ad ogni modo è tua responsabilità avere un backup integrale del tuo server, nel caso in cui qualcosa vada storto (magari, per ulteriore prudenza, fatti anche uno snapshot del server dal pannello di Aruba e un backup della tabella delle partizioni). Considera che è sufficiente un solo comando sbagliato per perdere tutti i dati. Io non posso garantire in alcun modo che ciò che ha funzionato a me possa funzionare anche a te, quindi stai attento e prima di impartire ogni comando assicurati di aver capito cosa stai facendo.

Le due strade percorribili per allargare il disco LVM senza smontare alcuna delle partizioni esistenti:

  • la più sicura è aggiungere una nuova partizione fisica primaria (se il numero massimo di partizioni primarie non è già stato raggiunto);
  • la più rischiosa (ma necessaria se non è possibile aggiungere ulteriori partizioni) è "sostituire" con fdisk l'ultima partizione fisica con un'altra che ha le stesse caratteristiche e lo stesso punto di inizio, ma dimensione diversa (ovviamente senza toccare i dati).

Vediamo in dettaglio queste due soluzioni.

ASUS ROG GL703VD-GC028T with Linux Mint 18.3 KDE is OK!!!

UPDATE May 4, 2018, from a blog reader who installed the dual boot of Linux Mint 18.3 and Windows 10 on ASUS ROG GL703VD-GC028T: «I installed finally Linux Mint. For installing Linux Mint with Windows 10 (UEFI), it is necessary to install Linux in UEFI mode (CSM = Disabled and choose UEFI option in start menu options). When the Grub is loaded, it is necessary to push E key and enter to Grub setup menu. In Grub setup menu, it is necessary to replace "quiet splash" with "nomodeset". Doing this, live Linux Mint loads and it is possible to install it. When Linux Mint is installed, it is necessary to do the same in the final Grub.
If you do not install Linux in UEFI mode, Windows won't detect Linux and then Grub is not loaded on startup.
»


Original article: It's not easy to find sure information about the Linux compatibility of ASUS ROG GL703V models. If you are reading this small post probably it's because you are interested in the Linux compatibility of ASUS ROG: I can confirm that Linux Mint 18.3 KDE version works gracefully on ASUS ROG GL703VD-GC028T out-of-the-box.

It's necessary to change some settings in the UEFI BIOS to start the Linux usb live, after that you can install Linux on the SSD. During the installation, I've chosen to use the full SSD, replacing the pre-installed Windows 10, so I have no experience of dual boot on this ASUS ROG model. (Note: I disabled the Secure Boot in the UEFI BIOS and, in the boot menu, I chose to install Linux Mint without UEFI Mode, that's fine if you don't need dual boot)

After the Linux Mint 18.3 KDE version installation, in the driver manager I enabled the proprietary drivers "nvidia-384" and "intel-microcode"  to get a full support of the hardware. Note that the Fn keys don't work, however you can easily change the brightness from the battery icon (if you cannot see it, click the top arrow in the bottom panel to see the hided icons).

I'm using the kernel 4.13.0-31-generic #34~16.04.1-Ubuntu GNU/Linux

I hope that this small review can help other Linux enthusiasts to choose a great Linux-compatible professional laptop. I've tested the ASUS ROG GL703VD-GC028T for about a month without experiencing real Linux compatibility problems (there are a few flaws in the suspend/hibernate functionalities and in the touchpad ergonomics, however I don't use them, I even disabled the touchpad in the BIOS). Audio and graphics are ok, the 17" monitor is excellent for reading and working, my VirtualBox virtual machines work very well and Linux Mint 18.3 KDE version is very stable and customizable. On a normal usage the battery life is about two hours. The fan is normally silent, but it becomes noisy on intensive operations or on a large amount of file transfer.

Happy hacking and happy GNU/Linux,
Francesco Galgani,
February 13, 2018

Pages

Subscribe to Guide