datalog (inference from facts and rules) using pyDatalog (pythonic datalog extension)

Gli ambienti desktop che ho usato (in varie loro versioni e configurazioni varie):

• GNOME Classico
• KDE Classico
• XFCE
• GNOME Shell
• KDE Plasma
• MATE
• Cinnamon
• Unity
• altri meno e non mi sento di menzionare oltre

https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current-live/amd64/iso-hybrid/

Fase 1: Il puntatore di istruzione (IP, Instruction Pointer), seleziona quale istruzione leggere dalla memoria ROM di programma formato da una serie di istruzioni. L’istruzione corrente fluisce in 4 destinazioni che la scompongono: 2 che sono la sorgente e la destinazione di copia di bits di memoria, e 2 che sono i puntatori alle 2 possibili istruzioni successive, selezionate dal Path Selector (PS, selezionatore di percorso).

Fase 2: Avviene la copia del bit (parte di informazione) tra sorgente e destinazione. Questo può anche modificare il Program PS (Path selector), coi suoi effetti.

Fase 3: Viene aggiornata l’istruzione corrente mediante IP (Puntatore a istruzione). L’istruzione corrente specificamente consiste nella istruzione contenuta nella memoria ROM individuata dall’indirizzo del Puntatore a Istruzione, indirizzo contenuto nel Puntatore a Istruzione.

Nota: forse tra imprecisioni e varianti possibili di questo design le cose non sono esattamente così, ma con differenze.

Ecco mostrato come un programma viene eseguito, istruzione per istruzione, con ogni istruzione avente 2 possibili istruzioni prossime, con selezionatore di istruzione prossima, e con il nocciolo dell’istruzione che consiste nella copia di bits con 2 posizioni una come fonte da cui prelevare il dato, l’altra come specificazione del dove collocarlo. Muovendo bit si ha anche immissione ed emissione di informazioni, che possono così essere elaborate.

Con queste semplici istruzioni è possibile derivarne ogni altra essendo Turing Complete il design. Io ne ho derivate ad esempio istruzioni dell’algebra di George Boole per fare operazioni di somma e conteggio.

Una sua variante però potrebbe avere accesso indiretto alla memoria, ovvero con memorie in RAM contenenti indirizzi da cui leggere informazioni o scrivere informazioni, un pò come il PEEK & POKE nei sistemi BASIC. Ovviamente una Turing Machine classica a memoria su nastri magnetici avrebbe qualche problema a fare questo, anche se non sarebbe impossibile tecnicamente.

Linux. Avete sentito qualcosa a riguardo o non sareste qui a leggere. Oppure è un primo contatto che è privo di preconcetti.

Le mie opinioni: prime di enunciarle dico che sono un utente antico ed esperto, con interessi nell’ambito della programmazione di software (siti web e app incluse) e amministrazione di sistema (che potrebbe arrivare ad includere amministrare distese di computer attivi a servire le richieste di decine su decine di utenti, creando un carico di lavoro notevole).

Io ho conosciuto Linux come kernel. Ovvero nel mio bagaglio di conoscenze tecniche so che è un componente essenziale di un sistema operativo. Ad esempio Android è un sistema operativo. E Android usa un adattamento del kernel Linux.

Linux è quindi un kernel adattabile. Può adattarsi agli smartphone e tablet, ma può anche servire in una moderna apparecchiatura elettronica come ad esempio una lavatrice smart.

Questi sono adattamenti in piccola scala mentre essendo Linux un kernel scalabile può adattarsi anche a una più grande scala. Come la larga scala di un Facebook o di una Wikipedia in cui tanti computer di tipo server hanno un sistema operativo con kernel Linux e assieme ad appositi software (che si appoggeranno al kernel essendo il kernel alla base) questi computers gestiranno i siti web anche molto usati e quindi con grandi carichi di lavoro e con esigenze di memorizzazione anche elevatissime (vedasi Facebook quanto memorizza nei suoi computers servers).

Oppure anche nel super calcolo: molti computer agiscono come clusters per supportare enormi calcoli e carichi di lavoro ad esempio di fisici o di ingegneri, ad esempio con simulazioni e previsioni, statistiche, suggerimenti smart, profilazione, etc che richiedono grosse prestazioni.

E? E poi? Dicevamo sull’inadeguatezza! Fin qua tra Android, centri di calcolo, servers per ospitare Facebook, elettrodomestici smart, smart TV, etc, fin qua non è inadeguato!

E’ inadeguato in un campo di sicuro: l’utenza comune. Linux per l’utenza comune non fornisce soluzioni adatte (aspetta!). Ma in che senso? Allora… Android usa una versione adattata del kernel Linux. E Android ha una interfaccia secondo me al top di quelle che esistono oggigiorno. Ma Linux è il Kernel, una parte sottostante, un nocciolo centrale, il cuore, non il viso chessò. Per dare un viso al kernel il team Google ha fatto progressi e successi ben noti.

Mentre, nei sistemi PC Linux è stato il cuore di vari sistemi operativi per PC (e lo è tuttora che scrivo), ma tali sistemi PC (Personal Computer) hanno seri e gravi problemi e carenze nel fornire un’esperienza adatta agli utenti comuni quindi non particolarmente esperti.

Sono stati fatti passi avanti però da non nascondere: molti più applicativi, giochi inclusi adesso supportano tali “PC Linux” e forse … chissà, non pronostico.

Nella mia esperienza di utente non comune bensì tecnico e smaliziato (che vocabolo!) ho avuto la possibilità di un uso quotidiano anche perché non gioco sul PC, non uso Softwares che non supportano PC Linux, anzi uso dei softwares che a volte sono prodotti per funzionare solo su PC Linux, caso opposto.

Aggiungo oggi 13/11/2023: uso un PC laptop con Windows 11 e Manjaro e Ubuntu, più un server online Debian. Non mi limito nell’ uso del software, non sono più “Linux first” bensì non voglio né favorire né sfavorire. La parte politica del tema la lascio ancor più di prima al passato. Il presente non ha tensioni. No politica, no ideologie, no fazioni. Guardo i software in modo concreto per le esigenze e le possibilità e le limitazioni.

Ecco un “/dev/sda” (disco interno) partizionato. Ci sono partizioni (ovvero suddivisioni), per le necessità di memoria di ben 4 Sistemi Operativi: MS Windows10, Ubuntu 21.10, Fedora 35, Debian11.

Come nota aggiuntiva dico che: è bene ricordare di non interrompere le operazioni di manutenzione ad esempio quelle di GParted perché si potrebbero perdere strutturazioni di dati e quindi dati. Una volta iniziate terminarle ed assicurarsi di avere disponibili tempo, alimentazione elettrica. Fare comunque backups anche appoggiandosi a DropBox etc.

E non ultimo per modificare una partizione non deve essere in uso: ad esempio ho ampliato mediante GParted la partizione Debian non da Debian avviato ma da Ubuntu avviato perché così la partizione Debian da modificare non era in uso e quindi modificabile.

Se potete appoggiarvi a sufficientemente esperti potrebbe risultare meglio, o anche nel tempo divenire esperti. Se c’è possibilità di perdita di dati è una responsabilità.

Altra cosa: allocare cioè assegnare risorse per usarle è una cosa tattica per così dire. Dividete l’hard disk in modo tattico per non avere problemi futuri strada facendo.

Mentre in quanto a multi-boot di compresenza di sistemi operativi consiglio imparare di più su GRUB e sulla eventuale presenza di un sistema recente con UEFI e non un vecchio BIOS senza: UEFI agevola il multi-boot tenendo copie separate di GRUB + boot di Windows (io ho più di 4 voci di avvio nel UEFI anche per vecchi sistemi, e Microsoft Windows (!) che può essere avviato così anche senza GRUB, che è tipicamente un boot loader della famiglia Linux)

https://certbot.eff.org/

CertBot lo uso nei miei domini/websites:

# from ~/.bash_history

cd /var/www && ls
mkdir alias.arkenidar.com
touch alias.arkenidar.com/test.txt

cd /etc/apache2/sites-available/
nano alias.arkenidar.com.conf 
a2ensite alias.arkenidar.com
systemctl reload apache2

sudo certbot --apache -d arkenidar.com -d netop.info -d alias.arkenidar.com

https://arkenidar.com/docs/snippets/alias-howto.txt

Ecco come uso linode e dynu per avere un server con IP e dare almeno un nome a quell’IP statico (fisso, non cambia, a differenza dell’utenza comune che ha IP variabili)

Queste sono le app che uso di questi tempi, specificamente nell’ambiente software di Debian 11.

Come dico anche nel titolo nel blog ogni software può essere sia migliorativo che peggiorativo. Usateli con coscienza.

Forse dettaglierò in futuro su ciascuno degli elementi mostrati.

https://arkenidar.com/var/sh-scripts/

Linguaggi e interfacce di programmazione: le basi di ogni software.

Per essere capace di essere un programmatore bisogna conoscere entrambi gli elementi: sia i linguaggi di programmazione sia le interfacce di programmazione comunemente abbreviate come “A.P.I.” (application programming interface).

In una applicazione bisogna usarli entrambi. Nella mia esperienza ho una buona dimestichezza con lo studio dei linguaggi (imparentati e “a famiglie” di somiglianza, e aventi influenze sia ricevute che date). Le somiglianze rendono possibili il riciclo delle conoscenze, una ri-applicabilità di ciò che è stato compreso. Un linguaggio può essere implementato in più modi e ciò può essere rilevante.

Riguardo le API ovvero le interfacce di programmazione ne esistono svariate e a volte determinano il linguaggio che va con esse usato. Quindi sono vincolanti. Sono più soggette a un mutamento di versione in versione e anche per questo richiedono lo studio della documentazione specifica. Possono anche invecchiare e divenire obsolete o anche non più supportate. Vincolano al produttore e al mantenitore con i suoi interessi di mercato e strategici.

Love2D is a way to build apps. It is based on the distribution of compressed bundles of files, usually a “main.lua” Lua script file plus other Lua scripts and optionally other files, tipically images and sounds.

Love2D is mainly a way to build game apps with 2D graphic. It can leverage some of its cross-platform ability, both mobile and classic desktop systems.

To activate a Love2D app you must use an installer with file extension association (or install its package). Extension association is a way to usually launch such apps, the other is in this form: “love gamefile.love”. The extension of the zipped compressed app bundle is “.love” in fact, and the above way is meant to launch the love2d app using the “love” runtime executable and the file to open as a “command line argument”, usable both in consoles and in desktop app launcher files (e.g. Windows or Linux app Icons).

The “love” executable file is a runtime that can run both zipped “.love” files and directories containing Lua/Love2D scripts also. Such directories must contain at least the “main.lua” file as app entry-point for program execution, and such directories can be distributed by zipping such contents with a zip compression program/command and renaming such zip file to a love file extension: app.zip -> app.love.

To write such script textual files describing the program you can use a Lua IDE such as ZeroBrane Studio (written in wxlua) or Microsoft’s Visual Studio Code extendible IDE with Lua specific “extensions” from the “VSCode Extension Marketplace” (BTW VSCode is built mainly in JavaScript).

Perché metto in guardia dall’informatica con le sue espansioni in continua espansione?

Anche soltanto notare ciò è molto utile per capire che posto può avere l’informatica nelle nostre proprie vite e nei nostri ambienti.

Per me l’informatica ha avuto tanti effetti e fasi sia di conoscenza e sia dell’evoluzione dell’informatica stessa nella mia vita.

La tendenza è che questo campo cresca, ci sono investite troppe energie affinchè questa crescita avvenga.

Ma cresce anche la complessità da gestire e io ho conosciuto scenari da incubo e pazzia. E non si è fermata minimamente questa crescita.

Che fare?

ADDENDUM: mancava una immagine a questo articolo quindi metto questo video (abbastanza attinente)

CppCon 2015: Fedor Pikus “C++ Metaprogramming: Journey from simple to insanity and back” https://www.youtube.com/watch?v=CZi6QqZSbFg

#include <stdio.h>
#include <stdlib.h>

int main(){

    struct Nodo{
        int contenuto; // lista di "int"
        struct Nodo* collegato; // nodo successivo
    };
    struct Nodo* lista=NULL; // collegato al primo nodo

    struct Nodo* ultimo=NULL;
    for(int n=1; n<=3; n++){ // aggiungi: quanti?

        printf("aggiungi n=%d\n",n);
        
        struct Nodo* corrente=(struct Nodo*)malloc(sizeof (struct Nodo));
        corrente->contenuto=n;
        corrente->collegato=NULL;
        
        if(ultimo==NULL) lista=corrente;
        else ultimo->collegato=corrente;

        ultimo=corrente;
    }

    struct Nodo* scorre=lista;
    while(scorre != NULL){
        printf("scorrendo n=%d\n",scorre->contenuto);
        scorre=scorre->collegato;
    }

    return 0;
}

https://replit.com/@dariocangialosi/liste-collegate-liste-linked

Parlerò di un campo della tecnologia delle informazioni che è circoscritto alla creazione e mantenimento delle applicazioni web.

Una applicazione web è formata da web servers ai quali si connettono i web client, spesso browsers a volte app di altro genere, comunque mediando le due tipologie (client+server) con un protocollo di comunicazione in rete chiamato HTTP.

Dando per buono che Java sia una buona scelta, cosa si può usare per costruire un webserver in Java? “Spring.io” è un sito che fornisce principalmente questo, anche se si è evoluto temporalmente.

Java lo si può apprendere da “SoloLearn.com”, come linguaggio, mentre Spring è un uso di tale linguaggio.

Per iniziare un uso di Spring in Java o JVM ho usato:

https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.5.1.RELEASE&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=demo&name=demo&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.demo&dependencies=devtools,web,session,freemarker,jdbc,data-jdbc,postgresql,data-rest

Le “dependencies” sono parti da cui dipenderà la nuova webapp, perchè le userà, prevedibilmente. Fatto questo si scarica il “progetto” (nel senso di app in lavorazione) e lo si modifica ad esempio con Visual Studio Code, uno dei “https://spring.io/tools”:

https://marketplace.visualstudio.com/items?itemName=Pivotal.vscode-boot-dev-pack

E’ una app che usa un datasource, che va configurato come sorgente dei dati (datasource: gestione dei dati immagazzinati). Io in questo file “application.properties” uso Postgres ma avevo già bazzicato con una configurazione equivalente con MySQL (entrambi tipi di database software).

https://github.com/arkenidar/spring-demo1/blob/master/src/main/resources/application.properties

Fatto ciò l’app parte senza errori, ma non fa nulla, nè può fare nulla in questa condizione iniziale embrionale.

Ho quindi aggiunto delle classi controller MVC (già sperimentate e studiate tempo fa) che avevo scelto come piccoli esempi e prove in piccola, minuscola scala.

https://github.com/arkenidar/spring-demo1/tree/master/src/main/java/com/example/demo/controllers

Fatte queste modifiche (che nel mio caso fanno riavviare automaticamente il server, in modo che le metta in atto) posso quindi accedere agli indirizzi http del server http locale, in ascolto sulla porta 8080 (http://localhost:8080/fm).

“Fm” come FreeMarker un sistema di templating, di cui ho fatto un minimo iniziale uso.

Faccio anche uso di meccanismi di sessione http, e di JDBC un sistema per i DB (database).

Su Udemy ci sono video corsi estesi, ma per me molto pesanti da seguire, ho trovato un varco in questa jungla con tentativi più auto-diretti che passivamente imboccati (anche perchè conoscevo già PHP con e senza frameworks MVC).

== Punti da trattare, in ordine apposito.

=1 Cos’è un Sistema Operativo (OS) e in particolare Ubuntu.

• La gamma dei sistemi operativi.
• Uso desktop e uso Server.
• Installazione di Fedora Workstation in locale.

=2 Come acquistare un server Ubuntu sempre online, con opzionale DNS.

• Acquisto di un server con installato Ubuntu mediante Linode.com.
• DNS gestito mediante Dynu.com.

=3 Operazioni quotidiane in Ubuntu (SSH, aggiornamenti, installazioni, configurazioni mediante Nano o VSCode via SSH, rsync).

• SSH login e logout.
• APT upgrade e reboot.
• APT install e APT remove.
• GNU nano editor di testo dei file di configurazione, in modo testuale.
• Microsoft VisualStudio Code per editing di files remoti, su server, in modo grafico.

=4 Installazione Apache2 e HTTPS mediante Certbot.

• Installazione di Apache2.
• Configurazione del sito Apache2 disponibile e abilitato.
• Certbot per avere i siti Apache2 ovvero HTTP con HTTPS (più sicuro e necessario).

=5 Installazione di PHP.

• Installazione dei pacchetti mediante APT.
• File PHPinfo di prova temporanea e verifica.

=6 Installazione di MySQL (LAMP: Linux Apache MySQL PHP).

• Installazione dei pacchetti mediante APT.
• MySQL usabile da PHP.
• Gestione di MySQL mediante un apposito software, da remoto ma sempre in sicurezza.

=7 WordPress (un caso di uso di LAMP).

• Installazione download dal sito wordpress.org.
• Prima configurazione.
• Primi post.
• Amministrazione quotidiana.

GNU/Linux è la base di molte Distro, Sistemi Operativi molti dei quali usati nei computer online, i computer server. I server hanno sistemi operativi adatti a operare come server, spesso come server web (HTML/HTTP) ma anche come server di gioco, di videoconferenza e altri usi.

Nell’immagine sopra mostro come ho usato due servizi: Linode e Dynu. Linode pagandolo mi fornisce un computer sempre online a un indirizzo fisso, che è numerico e che posso usare più agevolmente come indirizzo non numerico (ad esempio “arkenidar.com” come indirizzo) mediante un sistema DNS, dei nomi.

Mediante SSH posso amministrarlo, come accenno.

Nella parte 4 parlo dei files nascosti.

Un file (che può anche essere un file di tipo directory) se inizia con un . (punto) allora non viene mostrato, tranne nei casi questo sia esplicitamente richiesto.

ls di default, senza specificare -a (All, tutto) non mostra tutti i file. Invece ls specificando -a elenca tutti i files (files del percorso specificato, e se non specificato files della directory corrente).

BASH e i files: la directory corrente e il percorso per riferirsi a un file.

I comandi (commands) menzionati negli articoli precedenti di questa serie (cp, mv, rm, mkdir) vengono eseguiti tipicamente all’interno di un’interfaccia testuale (ad esempio KDE/Konsole con shell GNU Bash).

Di BASH ne è ho parlato poco ma la menziono perchè è questa che ci fornisce il concetto di “directory corrente” (del processo in esecuzione). Questa directory corrente è usata dai processi che vengono creati quando un comando viene messo in esecuzione (ad esempio digitato non parte, dando il tasto di nuovo rigo il comando parte mediante l’interpretazione del rigo di comando da parte di BASH, che è anche un processo genitore e il comando dato è un processo figlio creato dal genitore, gerarchicamente).

Quindi… Se la directory corrente è la mia “home directory” (utente arkenidar quindi /home/arkenidar), se io creo un nuovo file vuoto con il comando touch così touch nomefile.txt il risultato è che viene fuori un file con questo nome completo: /home/arkenidar/nomefile.txt

Questo vale anche per tutti i comandi usati da shell BASH. Ad esempio: rm nomefile.txt rimuove il file così chiamato cercandolo nella directory corrente.

Se io faccio adesso rm percorso/nomefile.txt cercherà il file all’interno della directory percorso.

Esistono anche dei riferimenti particolari in BASH e in Unix in genere: . (punto) e .. (punto punto).

Lo spiego in pratica: al punto singolo viene sostituito il nome della directory corrente (ad esempio la directory home, ma con cd si fa un cambio directory).

cd nomedirectory farà entrare nella sotto-directory nominata, mentre cd .. farà entrare nella directory appena superiore alla directory corrente, superiore di un livello, rendendo la directory superiore la directory corrente (quella immediatamente superiore, ma se ci fossero più directory superiori si può usare ancora il .. con ad esempio ../.. che indica sopra di due livelli).

Questo forma il percorso di un file. Ad esempio a partire dalla directory radice (directory /) /home/arkenidar o a partire dalla directory corrente /home/arkenidar/sottodirectory: cd ../sottodirectory2 (che diventa quindi /home/arkenidar/sottodirectory2).

NOTA: Vedendoli in azione questa spiegazione testuale può divenire più decodificabile. Scusate se non fornisco immagini o video in questo momento.

I files più particolari in questo articolo sono le directory (o cartelle, come vengono chiamate) che possono ospitare al loro interno dei files.

Si scopre così la gerarchia di directories perchè ad esempio la directory / radice (root) contiene la directory home (/home) che contiene i files degli utenti (nel mio caso dell’utente arkenidar diventa: /home/arkenidar)

Ma una directory oltre a contenere files di tipo directory può contenere solo files e nessuna cartella (quindi questa profondità non continua indefinitamente) o anche essere directory vuote (nessun contenuto in quel momento).

Una directory viene creata con il comando mkdir. Ad esempio mkdir Schermate. Una directory viene creata col nome file specificato, ed è inizialmente vuota.

Una directory può essere rimossa con rmdir che va usato così: rmdir -rf Schermate. Le opzioni r ed f sono spiegate nel manuale: man rmdir.

Articolo 1 della serie di articoli sui files in Unix e quindi GNU/Linux.

I files vengono creati, hanno date di creazione e altro, occupano uno spazio nella memoria in base alla loro dimensione e hanno dei contenuti quindi.

Ma la cosa più importante è che i files hanno un nome, che serve a indicarli, individuarli, a riconoscerli e a farci riferimento.

Ad esempio un file può essere copiato (copy) così:

cp [origine] [destinazione] (vedasi man cp)

Ad esempio: cp pagina.html pagina2.html

Ecco quindi che il nome della nuova copia sarà la destinazione, ovvero pagina2.html.

Parentesi: Esiste un comando per evidenziare le differenze tra files: per esempio diff pagina.html pagina2.html non dovrebbe inizialmente mostrare differenze, poi se la copia verrà modificata, allora si che avrà differenze.

Se si vuole che il file origine scompaia, e rimanga il file di destinazione allora quello che forse vi tornerà utile è il comando mv che muove (move), sposta, quindi senza creare una copia. È utile se ci pensate anche a cambiare nome a un file. Ad esempio mv pagina.html index.html.

Per cancellare un file si può ad esempio usare rm (remove) che sgancia un file dal filesystem che quindi va perso pur non essendo fisicamente sovrascritto ancora (vedasi i tools di wiping e implementazioni di filesystems che sono fuori da questa serie di articoli). Alcuni usano un posto dove conservare i file prima di rimuoverli definitivamente che nei Desktop Environment (Ambiente di Scrivania) viene chiamato Cestino (metafore fisiche di Scrivania e Cestino). Ma questi comandi come rm non ne tengono particolare conto, perché precedono concettualmente l’avvento degli ambienti grafici e sono rimasti fedeli a quello stile. Se volete mantenete delle copie voi stessi con procedure apposite (come ad esempio i backups, fuori dalle tematiche dell’articolo).

Comandi cp, mv, rm. E con questo esempio di operazioni sui files di: copia, spostamento (e rinominazione), e cancellazione (senza passare dal Cestino), chiudo questo articolo di weblog e ci orientiamo verso i successivi in senso cronologico e di praticità. Ad esempio non sappiamo niente ancora su files speciali (ad esempio i files nascosti e le directory/cartelle).

Debian&KDE: Setting up a Debian10(codenamed:Buster) with KDE-Plasma (as DE)

A new operating system: Debian, side by side with others like Microsoft Windows.

Trick: (the ISO format was originally for CDs and DVDs, so you can write the ISO files there, in case)

BEGIN with a Download the ISO image file (for installing it)

https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/

1. The choice of “non-free”. First thing select a “non-free” version that means that it contains also Wi-Fi drivers(firmware), useful when you want of course to use Wi-Fi.
2. The choice of a “live ISO image” so you can try it before installing: https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current-live/
3. The choice of CPU type: https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current-live/amd64/
4. The choice of download type: https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current-live/amd64/iso-hybrid/
5. The choice of DE (KDE Plasma), search KDE .ISO: https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current-live/amd64/iso-hybrid/debian-live-10.9.0-amd64-kde+nonfree.iso

THEN having the ISO file “flash” it with Etcher

https://www.balena.io/etcher/ Use Etcher to flash the chosen ISO file to USB Flash Drives or SD Cards (removable storage). This removable storage once flashed can start a live OS that can be tried and/or installed on the main storage, in a disk partition. (Be sure to understand the concept of Partition, so you preserve what you eventually want to preserve and yet find room for installing a new Operating System, O.S. like the one you already have possibly, Windows. I use both!).

FINALLY boot the computer from the flashed memory with the new OS to “try it and install it”

(you can refer to YouTube videos from now on, here I focused on 1- selecting the proper ISO file giving you also freedom of choice by means of understanding and room for further exploration especially in terms of DE, Desktop Environments like KDE Plasma and so on) 2- writing the ISO file to external disk to boot from it and try it and install it

These commands tweaked and used from a proper bash terminal allow to:
## get the ISO file by HTTP download
wget https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current-live/amd64/iso-hybrid/debian-live-10.9.0-amd64-kde+nonfree.iso ## download the ISO file mentioned by means of “wget” command
## write the ISO file to external disk (/dev/sdb???) to start it after powering the computer of course if external disk is 1-inserted and 2-selected
sudo dd if=debian-live-10.9.0-amd64-kde+nonfree.iso of=/dev/sdb bs=4M status=progress && sync && echo “@@@ ALL IS OK! successful…” ## alternative to Etcher

(writing in progress)

https://www.section.io/engineering-education/tcp-node/

https://riptutorial.com/node-js/example/22405/a-simple-tcp-server

Rsync permette di sincronizzare i files tra due posizioni anche tra locale e remoto e viceversa.

devtool: rsync https://docs.google.com/document/d/1UFmfLRkGh0yY-OWlgmtYjkDYTWisEmf_jVhLmiJeumg/edit?usp=sharing

per vedere il codice di origine: https://arkenidar.com/tools/code.php

In Java si può anche usare zenity così (vedi sotto) nel momento in cui System.console() non è disponibile (not available). Ad esempio se il processo è in esecuzione da un IDE (e non da terminale apposito, alternativa anche questa).

Naturalmente zenity va installato (per essere richiamabile come da console).

/*
Console console = System.console();
if (console == null) { System.out.println("No console available"); return; }
else System.out.println("console available! (debug info)");
String line = console.readLine("");
*/

String line="<error: uninitialized line input>";
try {
    Process process = Runtime.getRuntime().exec("zenity --entry");
    InputStream inputStream = process.getInputStream();
    Stream<String> lines = new BufferedReader(new InputStreamReader(inputStream)).lines();
    line = lines.collect(Collectors.joining("\n"));
} catch (IOException e) {
    e.printStackTrace();
}
System.out.println(line);

This is a rectangular area calculation given its 4 vertices’ coordinates (axis-aligned). I had to do some research on various how-tos.

#lang racket
(define rect1 '( (1 1) (5 1) (1 -2) (5 -2) ) )
(define xmin 'undefined)
(define xmax 'undefined)
(define ymin 'undefined)
(define ymax 'undefined)
(define (bounds point) (begin
   (void (let
       ( (x (list-ref point 0))
     (y (list-ref point 1)) )
     (begin
   (if (equal? xmin 'undefined) (set! xmin x) (if (< x xmin) (set! xmin x) '()) )
   (if (equal? xmax 'undefined) (set! xmax x) (if (> x xmax) (set! xmax x) '()) )
   (if (equal? ymin 'undefined) (set! ymin y) (if (< y ymin) (set! ymin y) '()) )
   (if (equal? ymax 'undefined) (set! ymax y) (if (> y ymax) (set! ymax y) '()) )
   )
     
   ) ) )
   )
(bounds (list-ref rect1 0))
(bounds (list-ref rect1 1))
(bounds (list-ref rect1 2))
(bounds (list-ref rect1 3))
(list xmin xmax ymin ymax)
(- xmax xmin)
(- ymax ymin)
(* (- xmax xmin)
(- ymax ymin) )

Welcome to DrRacket, version 7.4 [3m].
Language: racket, with debugging; memory limit: 128 MB.
'(1 5 -2 1)
4
3
12
> 

2021 February 18:

• https://fsharpforfunandprofit.com/posts/printf/ supports arguments (count and types) check

2021 March 23:

• http://rosettacode.org/wiki/Classes#F.23

• https://stackoverflow.com/questions/36752742/comparing-f-and-ocaml

• https://fsharpforfunandprofit.com/posts/thinking-functionally-intro/

• https://ocaml.org/learn/tutorials/basics.it.html

https://fsharp.org/use/linux/

https://fsharp.org/about/

Out of curiosity mixed with desire to have the best programming tools starting with the best language possible and the best runtime possible (it mentions tooling software also)

Evaluating it led me to the situation shown below:

Further info:

(bash) sudo rpm –import https://packages.microsoft.com/keys/microsoft.asc
(bash) sudo wget -O /etc/yum.repos.d/microsoft-prod.repo https://packages.microsoft.com/config/fedora/33/prod.repo
(bash) sudo dnf install dotnet-sdk-5.0

… for current SDK (5) on Fedora 33

https://docs.microsoft.com/en-us/dotnet/fsharp/get-started/get-started-vscode

… for F# in VSCode first steps

realtà di collaborazione … anche per l’animale tecnologico

Git, GitHub, GitLab e la stesura dell’origine dei software

Altre mie presentazioni non pubblicate qui …

https://it.wikipedia.org/wiki/Programmazione_strutturata

https://llvm.org/

https://www.micro-examples.com/public/microex-navig/doc/095-asm-translator.html

La macchina di Turing ha segnato a fondo il concetto di cosa sia un computer. I programmi venivano codificati come una lunghissima sequenza d’istruzioni. Tali sequenze vengono eseguite sequenzialmente, spostandosi in una casella a destra o a sinistra nel caso di un nastro magnetico. Nel caso di una memoria ad accesso arbitrario l’ordine di esecuzione delle istruzioni è “avanti per default” altrimenti salta verso una specifica istruzione anche non adiacente. Questo default consente ad esempio di risparmiare memoria cosa che non avviene in una mia variante RESM dove ogni istruzione ha due e sempre due istruzioni successive. Il processore e i linguaggi C-like hanno ovviamente preso la scelta del “avanti per default” + “salti qualora bisogni”. E così vengono in essere istruzioni quali il GOTO del BASIC e ancor prima il JUMP del linguaggio macchina di cui sono importanti specialmente le varianti condizionali ovvero che avvengono soltanto a particolari condizioni.

Il GO TO, “vai a” … e la sequenza di istruzioni lineare divenne non lineare. Si pose il problema dello spaghetti code ovvero di tessiture indecifrabili di programmi che fecero nascere la programmazione strutturata che trovò la sua accettazione anche grazie al supporto nei linguaggi come Pascal e C …

Come nota dell’autore io tendo a conservare i pezzi d’informazione che permettono una comprensione storica ed evolutiva.

Queste sono le basi dei linguaggi e dei processori odierni. Nessuno ha mai pensato cose come rendere un programma non una sequenza d’istruzioni con salti, non una sequenza d istruzioni con salti disciplinati in gerarchie strutturate, ma un grafo di grafi ma non sarò io a introdurlo. In ogni caso vedo la necessità di mezzi visuali per definire i programmi. E non soltanto come testo decorato e “assistito” (come in VisualStudio con IntelliSense), ma come abbandono o integrazione della definizione di programmi mediante testo sequenziale, in oggetti grafici manipolabili e configurabili che esemplifichino il funzionamento del programma anche a fini di debug o refactoring. E già esistono varie notazioni e vari tipi di diagrammi ma non so perché i programmi debbano venire ancora scritti come files di testo semplice, poi elaborato.