Ditelo con... NXT-G

NXT-G e' l'ambiente di programmazione principale per i robot della Lego che utilizzano il componente (brick) NXT. E' un ambiente di programmazione grafico (la G della sigla), che consente di costruire il programma che il robot eseguira'.
Qualche dettaglio sul... ferro! Il componente principale del Robot e' il suo cervello, chiamato NXT Brick, che riceve fino a 4 segnali e governa fino a 3 motori. I motori possono governare ruote, facendo cosi' muovere il robot, oppure parti del modello. Sono disponibili diversi tipi sensori: dai piu' semplici sensori di contatto (un interrutore), ai piu' complessi sensori come quelli ad ultrasuoni e quelli per il riconoscimento del colore. Naturalmente tutti i componenti vanno montati assieme utilizzando i classici mattoncini della Lego.

Ma ecco il nostro esempio:

L'immagine del programma mostra il loop principale con l'utilizzo di una variabile di count. L'istruzione eseguita visualizza il messaggio in posizioni diverse sul piccolo display dell'NXT.
Per eseguire fare eseguire il programma questo va caricato sul robot e quindi avviato.

Tutto qui? No: Enchanting, ...

Ditelo con... il Prolog

Il Prolog e' un linguaggio che utilizza la logica dei predicati. Un programma e' costituito da una serie di fatti e di regole. L'esecuzione di un programma e' una dimostrazione basata sulle regole presenti.
La sintassi del linguaggio e' semplice ed e' basata sulla regola. La regola e' costituita da una lista di antecenti e da un conseguente. Se la lista degli antecedenti e' vera allora anche il conseguente e' vero. Se non ci sono antecedenti allora la regola e' sempre vera ed e' detta fatto. Il Prolog e' generalmente interpretato anche se esistono alcuni compilatori che generano un linguaggio intermedio di piu' veloce esecuzione.
Data la sua natura logica il Prolog e' utilizzato nella costruzione di sistemi esperti o di sistemi basati sulla conoscenza.

% Programma di esempio in Prolog

dimmelo:-dimmi(3).
dimmi(0).
dimmi(X):-
        writeln('Ti amo!'),
        Y is X - 1,
        dimmi(Y).

Un programma Prolog non si esegue... ad un programma Prolog si fanno delle domande! Nel nostro esempio basta chiedere: ?- dimmelo e lui rispondera'!

Tutto qui? No: ...

Ditelo con... Java

Il linguaggio Java, nonostante la recente introduzione (1995), ha subito ricevuto un'attenzione ed un utilizzo fortissimi. Il linguaggio Java e' universale nel senso che i programmi java precompilati (file .class) vengono eseguiti indifferentemente, e con gli stessi identici risultati, su qualsiasi piattaforma HW/SW che ospiti la Java Virtual Machine (JVM).
Si tratta di un linguaggio ad oggetti, compilato (su un bytecode che viene interpretato dalla JVM per essere piu' precisi) adatto a costruire applicazioni (come nel seguente esempio) o programmi scaricati da Internet ed eseguiti da un browser (applet come in un esempio sucessivo).
La programmazione in Java richiede una definizione rigorosa delle interfacce e delle eccezioni "costringendo" a scrivere programmi ben portabili e robusti ma... un poco complessi.

/**
        Esempio di programma in linguaggio Java
*/

public class Dimmelo 
{
    public static void main( String[] args )
    {
        int i;

        for (i=0; i<3; i++)                          
                System.out.println("Ti amo!");
    }
}

Il programma dell'esempio va scritto su un file (eg. Dimmelo.java), compilato con javac Dimmelo.java. Il compilatore genera un file in formato bytecode (con il suffisso .class) che puo' essere eseguito con java Dimmelo (naturalmente se e' stato definito in modo corretto il CLASSPATH).

Tutto qui? No: classi/oggetti/metodi/proprieta', bytecode, architetture distribuite, applet, servlet, beans, JDBC, classi fondamentali, RMI, ...
Riferimenti: Applet Java, JDBC, Sette architetture in cerca d'autore, Developing Custom and Standard Interfaces to Oracle RDBMS in Java, Using Java Standard Interfaces to Oracle, Kotlin, ...

Ditelo con... Scala

Il linguaggio Scala e' funzionale orientato agli oggetti. Scala e' stato introdotto nel (2001) ed utilizzato nello sviluppo di alcuni importanti software.
La compilazione di Scala produce bytecode Java e sono quindi facilmente utilizzabili in Scala componenti realizzati in Java.
Rispetto a Java la scrittura del codice e' piu' sintetica e comunque

/**
        Esempio di programma in linguaggio Java
*/

object Dimmelo {
  def main(args: Array[String]) {
    var i = 0
    for( a <- 1 to 3){
         println( "Ti Amo!" )
    }
  }
}

Il programma dell'esempio va scritto su un file (eg. Dimmelo.scala), compilato con scalac Dimmelo.java ed eseguito con scala Dimmelo.

Tutto qui? No: ...
Riferimenti: Java, ...

Ditelo con... JavaScript

JavaScript e' un linguaggio di scripting interpretato. Anche se il nome ricorda il linguaggio Java in realta' le differenze tra i due linguaggi sono molte. Ideato per essere inserito nel browser Netscape inizialmente si chiamava Mochan, poi nella versione Beta aveva preso il nome di LiveScript ed infine quello di JavaScript perche' contemporaneamente veniva supportato Java nello stesso browser... Il linguaggio e' stato successivamente standardizzato con il nome di ECMAScript e formalmente JavaScript e JScript (implementato da Microsoft) sono due implementazioni.

JavaScript e' un linguaggio interpretato orientato agli oggetti e agli eventi. JavaScript fa un forte uso di funzioni ed e' debolmente tipato.

// Esempio in Java Script

function dimmelo() {
  var i 
  for (i=0; i<3 ; i++) {
    console.log("Ti amo!");
  } 

dimmelo();

Quando non utilizzato all'interno di una pagina HTML i programmi JavaScript hanno suffisso .js.

Inizialmente JavaScript era utilizzato solo nei browser. Ma ci sono stati due importanti eventi che hanno cambiato in modo radicale il tipo di utilizzo del linguaggio JavaScript: Google nel 2008 ha rilasciato V8 (compilatore in linea di JavaScript) e nel 2009 e' stato presentato Node.js (ambiente di esecuzione di JavaScript con la capacita' di servire migliaia di richieste con un singolo thread).
JavaScript e' ora utilizzato sia per eseguire attivita' sul browser sia nel costruire le pagine sul web server sostituendosi ad Apache ed ad un Application Server.

Riferimenti: JavaScript (browser), Node.js, AngularJS, MEAN, ...

Ditelo con... JSON

Il JSON (JavaScript Object Notation) tecnicamente e' un sottoinsieme del linguaggio di programmazione JavaScript che non consente di scrivere alcun programma!

Infatti il JSON e' un semplice formato per lo scambio di dati. Per le persone e' facile da leggere e scrivere, per un programma risulta facile da generare e da analizzarne la sintassi. La sua semplicita' lo ha reso sempre piu' diffuso ed e' diventato uno standard di fatto per lo scambio di dati tra programmi.

JSON e' basato su due sole strutture: oggetti e vettori. Un oggetto e' un insieme di coppie nome/valore. Un vettore e' un elenco ordinato di valori che possono essere numeri, stringhe oppure oggetti e vettori.
La sintassi e' semplice perche' utilizza le parentesi graffe per gli oggetti, quadre per i vettori... meglio un esempio!

[ {"Messaggio" : "Ti amo!"}, {"Messaggio" : "Ti amo!"}, {"Messaggio" : "Ti amo!"} ]

Nell'esempio abbiamo utilizzato un array con tre oggetti. E' una stringa JSON sintatticamente corretta quindi puo' essere compresa da umani e macchine indifferentemente, dipende da chi vi siete innamorati ad a chi mandate il vostro messaggio.

Riferimenti: JavaScript, ...

Ditelo con... Java Bean

Quanto e' bello programmare con quei strani strumenti grafici che vedono tutto come un oggetto, riconoscono automaticamente le sue proprieta' e fanno credere nelle magnifiche sorti progressive!

In Java il mattone fondamentale per rendere possibile questa magia sono i Bean. Un Java Bean e' un oggetto che pubblica la sua interfaccia e permette il suo utilizzo in modo semplice da parte di un IDE.
La definizione e' semplice: un Java Bean e' una classe pubblica che implementa l'interfaccia Serializable con un costruttore senza argomenti. Un Java Bean puo' anche esportare proprieta', eventi, metodi ed una classe BeanInfo ma non e' necessario.
L'aspetto notevole dei Java Bean e' che vengono riconosciuti con tutte le loro proprieta' dagli ambienti di sviluppo (eg. un IDE) rendendone semplice l'utilizzo.

Chiaro? Forse no. Ma un Bean e' come un pisello: se non sai cos'e', e' piu' facile da vedere che da spiegare!
Ecco l'esempio:

public class DimmiBean implements java.io.Serializable {
  private String phrase;
  public DimmiBean() {
        phrase="Ti amo!";
  }
  public setPhrase(value) {
        phrase=value;
  }
  public getPhrase() {
        return (this.phrase);
  }
  public String dimmelo() { return (this.phrase); }
}

Nell'esempio viene definito un semplice Bean che, naturalmente, deve essere richiamato da un'applicazione con:

DimmiBean frase = new DimmiBean();
System.out.println(frase.dimmelo());

Tutto qui? No: Java, EJB (Enterprise Java Bean), ...

Ditelo con... Cache' ObjectScript

Cache' e' uno strumento RAD che unisce un DB relazionale con un profondo utilizzo dell'object oriented e dei servizi su web. Si tratta a tutti gli effetti di una base dati multidimensionale i cui contenuti possono essere visti nativamente come oggetti oppure come tabelle.

Il suo linguaggio di programmazione nativo e' l'ObjectScript che supporta tutti i costrutti tipici dei linguaggi ad oggetti.
L'ambiente di sviluppo utilizzato da Cache' e' Studio un potente IDE che consente la realizzazione di applicazioni in tempi molto rapidi.

/// Esempio di Classe in Cache'

Class Parole.Dimmelo 
{

ClassMethod Test() As %String
 {
        set frase=""
        
        for i=1:1:3
         { 
         set frase= frase _ "Ti Amo! "
         }
        Write frase
 }
}

Tutto qui? No: SOAP, ...

Ditelo con... LSL

LSL e' l'acronimo di Linden Scripting Language. Con questo linguaggio sono scritti tutti gli scripts in Second Life. La sua sinatassi e' simile a quella Java o C. Gli scripts in Second Life sono set di istruzioni posizionabili all'interno di qualsiasi oggetto o in qualsiasi accessorio indossato dagli Avatars. Vengono scritti con un editor apposito.
Una particolarita' di LSL e' il forte utilizzo degli stati e degli eventi. Ogni script ha sempre almeno uno stato: quello di Default. Gli eventi non sono definiti ma sono predefiniti dall'LSL. Il Touch_start(), esegue il codice al suo interno quando l'oggetto che contiene lo script viene toccato.

       // Script di esempio in LSL

       default
       {
            touch_start(integer total_number)
            {
                integer i = 0;
                for(; i<3; ++i)
                    llSay(0,"Ti amo!");
            }
       }

Nell'esempio toccando l'oggetto si ottiene la nostra romantica frase ripetuta per tre volte.

Tutto qui? Certo, non ho una seconda vita ...

Ditelo con... SQL

Il linguaggio SQL (Structured Query Language) e' nato come linguaggio di interrogazione per basi dati relazionali. In realta' il suo utilizzo non e' solo per l'interrogazione ma consente la completa gestione delle basi dati relazionali.
Il linguaggio e' definito di quarta generazione. Non si tratta quindi di un linguaggio procedurale ed e' di semplice utilizzo.
Il linguaggio SQL e' molto diffuso e ne esistono diversi dialetti forniti dai diversi database relazionali (eg. Oracle, PostgreSQL, MySQL, DB2, SQL Server, SQLite, ...). Tuttavia le istruzioni di base del DDL (data definition language) e DML (data manipulation language) sono comuni e sono state ben standardizzate.

REM Script di esempio in SQL

CREATE TABLE dimmelo (testo char(20));

INSERT INTO dimmelo(testo) VALUES('Ti Amo!');
INSERT INTO dimmelo(testo) VALUES('Ti Amo!');
INSERT INTO dimmelo(testo) VALUES('Ti Amo!');
COMMIT;

SELECT testo
  FROM dimmelo;

Nell'esempio viene creata una tabella, viene popolata con i dati voluti che infine vengono estratti con una selezione. Per eseguire i comandi SQL si deve utilizzare un interprete SQL o inserirli in un programma (scritto in C, in Cobol, in Visual Basic, ...). Nel caso di richiamo dall'interprete SQL di Oracle (che si chiama SQL*Plus) e' sufficiente creare un file "dimmelo.sql" e, una volta connessi alla base dati, lanciarlo con il comando "start dimmelo".
Mutatis mutandis lo script vale per tutte le basi dati relazionali. In effetti vi e' uno standard ANSI sull'SQL rispettato praticamente da tutti i produttori (per le funzionalita' core). Ad esempio: Oracle, PostgreSQL, MySQL, DB2, Informix, SQL Server, Sybase, SQLite, Firebird, ... La versione piu' recente dello standard e' SQL:2008.

Tutto qui? No: join, outer join, self join, select annidate, transazioni, integrita' referenziale, Two Phase Commit, ... Riferimenti: Oracle, ...

Ditelo con... PL/SQL

Il linguaggio PL/SQL (Procedural Language SQL) e' un'estensione dell'SQL disponibile con l'RDBMS Oracle. Il PL/SQL contiene una serie di estensioni "procedurali" all'SQL che lo rendono adatto alla programmazione. E' quindi utilizzato per la definizione di trigger e di stored procedures.
E' un linguaggio procedurale il cui codice viene compilato e viene memorizzato sulla base dati stessa. Il PL/SQL e' stato introdotto da Oracle da molto tempo, e' molto efficiente e dispone di un numero molto elevato di package di sistema.
Il PL/SQL deriva dall'ADA di cui conserva diversi costrutti sintattici e DIANA (Distributed Intermediate Annotated Notation) il linguaggio con cui veniva precompilato [NdA ed e' utilizzato nel wrapping].

REM Script di esempio in PL/SQL lanciato da SQL*Plus

set serverout on              

declare
        i number;
 
begin
for i in 1..3 loop
        DBMS_OUTPUT.PUT_LINE( 'Ti amo!');
end loop;
end;
/

Il blocco unnamed PL/SQL dell'esempio puo' essere eseguito collegandosi in SQL*Plus. Nell'esempio viene utilizzato un package (DBMS_OUTPUT) che consente di stampare la stringa voluta.

Nell'esempio precedente e' stato utilizzato un blocco PL/SQL anonimo. In amore e' giusto dichiararsi, e cosi' si puo' fare anche in PL/SQL. I due esempi seguenti dichiarano una stored procedure ed un package. Entrambe gli oggetti sono inseriti nella base dati Oracle e possono essere utilizzati a richiesta.

REM Stored procedure e package

create procedure dimmi3 is
begin
  declare
        i number;
  begin
    for i in 1..3 loop
        DBMS_OUTPUT.PUT_LINE( 'Ti amo!');
    end loop;
  end;
end dimmi3;
/

create package dimmi is
procedure dimmi3 ;
end dimmi;
/

create package body dimmi is
procedure dimmi3 is
begin
  declare
        i number;
  begin
  for i in 1..3 loop
        DBMS_OUTPUT.PUT_LINE( 'Ti amo!');
  end loop;
  end;
end dimmi3;
end dimmi;
/

Ora che gli oggetti sono stati creati sulla base dati e' possibile richiamarli da sqlplus con un execute dimmi3 oppure execute dimmi.dimmi3 (non dimenticate di abilitare l'output con SET SERVEROUT ON per riuscire a vedere qualcosa...).

In realta' il PL/SQL tipicamente si utilizza per analizzare i risultati di una query trattando i record con un cursore. Ecco un esempio:

DECLARE
     CURSOR c1 IS  SELECT * FROM tabella;
     conta   NUMBER;
 BEGIN
     conta := 0;
     FOR my_rec IN c1 LOOP
         conta := conta + 1;
     END LOOP;
 END;

Tutto qui? No: trigger, exceptions, SQL, Ada, ... Riferimenti: Oracle, ...

Ditelo con... PL/pgSQL

Il linguaggio PL/pgSQL e' un'estensione dell'SQL disponibile con PostgreSQL. Il PL/pgSQL contiene una serie di estensioni "procedurali" all'SQL che lo rendono adatto alla programmazione. E' utilizzato per la definizione di funzioni e di trigger. A differenza di altri linguaggi procedurali sui Database (eg. PL/SQL) non consente la creazione di stored procedures che pero' possono essere implementate come funzioni il cui valore di ritorno non viene considerato (RETURNS void).
E' un linguaggio procedurale il cui codice viene compilato e viene memorizzato sulla base dati stessa.

/* Stored Function realizzata in PL/pgSQL */

CREATE OR REPLACE FUNCTION dimmi3() RETURNS void AS $$
DECLARE i integer;
BEGIN
  FOR i IN 1..3 LOOP
    RAISE NOTICE 'Ti amo!';
  END LOOP;
END;
$$ LANGUAGE plpgsql;

Per eseguire la funzione bisogna collegarsi a PostgreSQL con il comando psql e richiamarla con SELECT * from dimmi3();

Tutto qui? No: SQL, PL/SQL, LAPP, ... Riferimenti: PostgreSQL, Qualcosa in piu' su PostgreSQL 9.0, ...

Ditelo con... DB2 SQL PL

Il linguaggio procedurale di DB2 (SQL PL) e' molto completo ed aderente allo standard SQL:2003. Con l'Inline SQL PL, un sottoinsieme dell'SQL PL che non consente istruzioni dinamiche (eg. PREPARE) o la gestione delle transazioni (eg. COMMIT), vengono create funzioni e trigger.

CREATE PROCEDURE dimmi3()
LANGUAGE SQL
BEGIN
  DECLARE i INT DEFAULT 0;

  WHILE i < 3 DO
    insert into messaggio values ('Ti amo!');
    SET i = i + 1;
  END WHILE;
END
@

Con db2 -td@ -fdimmi.sql la stored procedure viene creata (naturalmente deve esistere una tabella messaggio con un campo testo).

Tutto qui? No: SQL, ... Riferimenti: DB2, ...

Ditelo con... MySQL Stored Routines

Il linguaggio SQL fornito da MySQL e' stato esteso, dalla versione 5.0, per consentire la scrittura di Stored Programs. Gli Stored Program sono: Stored Routines (Procedure o Function), Trigger ed Event.
I MySQL Stored Programs utilizzano un linguaggio procedurale il cui codice viene memorizzato sulla base dati stessa. La sintassi e' compliant SQL:2003 (eg. DB2).

/* Stored Procedure realizzata in MySQL */

DROP PROCEDURE IF EXISTS dimmi3;
DELIMITER '/';

CREATE PROCEDURE dimmi3() 
BEGIN
  DECLARE i INT DEFAULT 0;

  WHILE i < 3 DO
    select 'Ti amo!';
    SET i = i + 1;
  END WHILE;
END/
DELIMITER ';'/

Basta collegarsi su MySQL con il comando mysql e lanciare lo script con CALL dimmi3(); Facile, vero?

Tutto qui? No: SQL, PL/SQL, PL/pgSQL, ... Riferimenti: MySQL, ...

Ditelo con... HPL/SQL

L'HPL (Hybrid Procedural Language) introduce i costrutti procedurali (variabili, controllo di flusso, funzioni) all'HQL di Hive. Con una sintassi simile a quella del PL/SQL

HPL/SQL e' incluso nella versione 2.0 di Hive ed era noto in precedenza come PL/HQL.

Tutto qui? No: PL/SQL, Hive, ...

Ditelo con... R language

L'R language e' un linguaggio funzionale intepretato fornito di un ampio insieme di funzioni matematiche e statistiche.
Con R vengono tipicamente realizzati script per l'analisi statistica dei dati. In R si sviluppano funzioni e le funzioni possono essere assegnate a variabili.
La sintassi del linguaggio R e'... praticamente identica a quella del linguaggio S ed inoltre puo' essere arricchito con funzioni realizzate e C e C++.

# Esempio in R language
dimmi <- function() {    for (i in 1:3) {        print("Ti amo!")    }}

Proviamo ad eseguirlo?

> dimmi()[1] "Ti amo!"[1] "Ti amo!"[1] "Ti amo!"

Un programma R viene chiamato script e salvato su un file con l'estensione *.R.
Ora vi sono diversi IDE che consentono di realizzare applicazioni graficamente molto accattivanti.

Tutto qui? Si!

Ditelo con... Pig Latin

Pig Latin e' il linguaggio di Pig: uno strumento l'analisi di grandi moli di dati. Pig utilizza un linguaggio di alto livello, facilmente programmabile, disegnato in modo da consentire un elevato parallelismo (realizzato con Map/Reduce).
Con Pig vengono tipicamente realizzati script che caricano i dati dal file system (LOAD) effettuano le analisi richieste (FILTER, JOIN, GROUP, ...) e scaricano nuovamente i dati ottenuti (STORE). Il file system utilizzato da Pig e' Hadoop Distributed File System (HDFS) un file system distribuito che consente di scalare dati ed elaborazioni su migliaia di server.

/* Esempio in Pig Latin */

A = LOAD 'BigData.csv';
B = FOREACH A GENERATE "Ti amo!";
C = LIMIT B 3;

DUMP C;

L'interfaccia da linea di comando si chiama Grunt e si richiama con il comando pig.

Tutto qui? No: Big Data, NoSQL, SQL, ... Riferimenti: ...

Ditelo con... Pig Latin (2)

Anche se il Pig Latin che abbiamo visto nel paragrafo precedente e' noto e diffuso in tutta la comunita' degli esperti dei Big Data c'e' un omonimo molto piu' conosciuto dai... bambini inglesi!
Infatti il Pig Latin e' un linguaggio parlato cifrato usato tra bambini e ragazzi inglesi per non far capire agli adulti di cosa si stanno parlando e difficilmente lo capirebbe chiunque in italiano:

Iay ovelay ouyay!
Iay ovelay ouyay!
Iay ovelay ouyay!

Itay omaay!
Itay omaay!
Itay omaay!

Naturalmente anche noi italiani abbiamo i nostri linguaggi segreti come l'alfabeto farfallino:

Tifi afamofo!
Tifi afamofo!
Tifi afamofo!

Tutto qui? Si!

Ditelo con... InfluxQL

InfluxDB e' il piu' potente e noto database Timeseries.
Utilizzato per memorizzare grandi quantita' di dati in serie temporali, InfluxDB ha un simpatico linguaggio di interrogazione chiamato InfluxQL.

Dal punto di vista sintattico InfluxQL e' simile all'SQL di MySQL anche se fondamentalmente si utilizzano solo le INSERT e le SELECT.

-- Script di esempio in InfluxQL
> INSERT messaggi,da=Meo,a=456c656e61 value=100.00,text="Ti amo!"
> INSERT messaggi,da=Meo,a=456c656e61 value=100.00,text="Ti amo!"
> INSERT messaggi,da=Meo,a=456c656e61 value=100.00,text="Ti amo!"

> SELECT "da","text" FROM messaggi  
name: messaggi
---------
time		    	        da          text
2015-02-14T19:28:69.580664347Z  Meo         Ti Amo!
2015-02-14T19:28:69.580664353Z  Meo         Ti Amo!
2015-02-14T19:28:69.580664369Z  Meo         Ti Amo!

In InfluxDB i dati sono organizzati in Time Series che contengono i valori misurati. Ogni misurazione e' detta point. Ogni point e' costituito dal timestamp, dalla misura e da uno o piu' valori; inoltre possono essere associati dei TAG che possono essere utilizzati per le ricerche o per i raggruppamenti. Tipicamente i punti vengono inseriti con il Line Protocol, ma puo' anche essere utilizzato l'InfluxQL.
L'API HTTP di InfluxDB e' in ascolto di default sulla porta 8086. Il client influx si collega a tale porta su localhost e consente di inserire i comandi indicati. Nell'esempio vengono inseriti, e poi selezionati, tre misure con il nostro romantico messaggio.
Nell'uso piu' tipico vengono inseriti misurazioni timeseries da IOT, computer, periferiche, interfacce di rete, ... ma certo e' piu' romantico cosi!

Tutto qui? No: SQL, ...

Ditelo con... PQL

Paglo Query Language (PQL) e' un nuovo linguaggio che consente di ricercare informazioni sull'indice di ricerca di Paglo.
Paglo e' un nuovo strumento per la raccolta automatica e la ricerca semplificata di informazioni sulla propria rete e sui sui servizi presenti. Distribuito con un licenza Open ha caratterische che lo rendono molto interessante per il futuro.

Dal punto di vista sintattico PQL e' molto simile all'SQL: la differenza principale e' che il PQL utilizza la base dati di Paglo che e' organizzata ad albero.

-- Script di esempio in PQL

INSERT INTO / values {
  apps => {
    com => {
      paglo => {
        alerts => {
          alert => { index => 'ev1', parent => 'Master', indexed => 0, title => 'Messaggio', description => 'Ti amo!', }  
          alert => { index => 'ev2', parent => 'Master', indexed => 0, title => 'Messaggio', description => 'Ti amo!', }  
          alert => { index => 'ev3', parent => 'Master', indexed => 0, title => 'Messaggio', description => 'Ti amo!', }  
  } } } }
}


SELECT *
  FROM /apps/com/paglo/alerts
  WHERE alert/title = 'Messaggio'    

Nell'esempio vengono inseriti, e poi selezionati, tre allarmi con il nostro messaggio.
Nell'uso piu' tipico vengono inseriti nell'albero della base dati computer, periferiche, interfacce di rete... ma certo e' piu' romantico cosi!

Tutto qui? No: SQL, ...

Ditelo con... il Postscript

Il linguaggio Postscript generalmente non viene utilizzato sui un computer bensi' su una stampante! Si tratta a tutti gli effetti di un vero e proprio linguaggio di programmazione con tutte le normali caratteristiche di tali linguaggi: variabili, funzioni, cicli, ...
E' un linguaggio intepretato ed e' molto efficiente per rappresentare con poche "istruzioni" font, disegni e grafici che, trasmessi in forma grafica come bitmap, sarebbero altrimenti di elevate dimensioni.

%!PS-Adobe-2.0 EPSF-2.0
%%A4: 21 3 588 788
%%Title:
%%CreationDate: 11:59 PM December  24, 2000
%%Pages: 1 +1
%%EndComments

% Esempio stampa testo
% Autore: Alessandro Ghiselli

%%Page: MainPage

% Definizione Variabili
/Var_amo  (...Ti amo!) def
/Var_amo2 (Ti amo!) def

% Selezione font e scala
/Times-Roman findfont 
20 scalefont         
setfont

% Prima fase
newpath

gsave

  740 20 780 {
  100 exch moveto
  gsave
     Var_amo2 show
  grestore
  } for

grestore
closepath

% Seconda fase
newpath

0 45 360 {
   300 600 moveto
   gsave
      rotate
      Var_amo show
   grestore
} for

closepath

showpage

Per far eseguire il programma riportato e' necessario inviare il file su una stampante. L'invio deve essere diretto (altrimenti viene stampato il testo del programma e non il suo risultato). Un altro modo di osservare il risultato e' quello di utilizzare un programma di visualizzazione dei file Postscript...

Tutto qui? Direi di sì...

Ditelo con... LaTeX

LaTeX non e' un linguaggio di programmazione ma di pubblishing.
LaTeX e' un ambiente per la preparazione di testi da stampare di alta qualita'. E' lo standard di fatto per i documenti di tipo tecnico e scientifico ed e' adatto anche a documentazione di grandi dimensioni e complessa (eg. formule matematiche, documenti tecnici, ...). L'idea di base di LaTeX e' quella di rendere indipendenti i contenuti del documento dai formati che verranno utilizzati nella stampa.
Un esempio e':

\documentclass{article}
\title{Ditelo con LaTeX}
\author{Meo Bogliolo}

\begin{document}
   \maketitle
   Ti amo!
   Ti amo!
   Ti amo!
\end{document}
      

Il testo viene scritto in questo modo dall'autore ed e' indipendente dalla modalita' di stampa e dalle scelte grafiche che possono essere fatte sucessivamente. Per convertire il testo in stampa vengono poi utilizzati programmi specifici (eg. TeX).

Tutto qui? No: HTML, ...

Ditelo con... il Visual Basic

Il Visual Basic (VB) e' un'evoluzione del BASIC. Rispetto al BASIC originale ha perso il numero di linea... ma acquisito la gestione della grafica e costrutti object-oriented.
Un programma VB e' event-driven ovvero guidato da eventi. Per esempio l'introdurre un testo in un campo oppure il premere un bottone. L'ambiente di sviluppo con cui si opera (Visual Studio) e' molto completo e contiente un editor per le maschere video, il debugger e diversi wizard che aiutano il programmatore nei compiti piu' complessi.
Nel nostro esempio basta creare una form (nome di default Form1) introdurre un bottone (nome di default Command1) e su questo scrivere il nostro codice in modo che venga eseguito quando il bottone viene premuto.

Private Sub Command1_Click()
For i = 1 To 3
Print "Ti amo!"
Next i
End Sub

Per eseguire un programma? Dipende! Da che dipende? Dipende... da cosa ne abbiamo fatto del nostro codice. Infatti in VB si possono generare eseguibili (normali .EXE a parte la necessita' di qualche DLL di supporto), oppure oggetti COM, oppure DLL, ... Naturalmente, visto che l'origine e' quella, e' anche possibile eseguirlo in modo interattivo premendo il pulsante "Run" sull'interfaccia grafica.

Tutto qui? Direi di sì...

Ditelo con... Python

Il Python e' un linguaggio di programmazione recente ma nonostante questo gia' molto diffuso, soprattutto per la realizzazione di script e programmi con interfaccia grafica su Linux. Lo sviluppo di Python e' Open Source fin dalla sua ideazione.
Python e' un linguaggio di programmazione interpretato, interattivo, object-oriented che combina una notevole potenza con un sintassi molto chiara ed intuitiva. Ad esempio non sono necessarie parentesi per racchiudere blocchi di statement ma si usa l'indentazione. Il risultato e' che i programmi sembrano quasi "meta script" molto semplici e leggibili.
Gli interpreti Python sono disponibili su molteplici piattaforme e rendono cosi' facilmente portabili i programmi scritti con tale linguaggio.

# Programma di esempio in Python

for i in range(3):
    print "Ti amo!"

Come eseguire un programma Python. Semplice! Dopo averlo salvato come dimmelo.py basta eseguirlo con il comando python dimmelo.py.

Tutto qui? Direi di no... date un'occhiata almeno a GTK, Tkinter, Jython, LAMP.

Ditelo con... Ruby

Ruby e' un recente linguaggio di programmazione intepretato e fortemente orientato ad una programmazione ad oggetti.
Il progettista di Ruby [NdE Matz] lo ha progettato con l'intento di rendere la programmazione divertente. Si tratta infatti di un linguaggio molto flessibile con cui spesso si implementano potenti DSL (Domain Specific Languages).
Ruby e' il linguaggio di programmazione del framework Ruby on Rails, la cui forte diffusione ha reso famoso anche il linguaggio.

# Esempio in Ruby 

(1..3).each do
   puts "Ti amo!"
end

Come eseguire un programma Ruby? Semplice! Dopo averlo salvato come dimmelo.rb basta eseguirlo con il comando ruby dimmelo.rb. Per lavorare interattivamente con Ruby si puo' utilizzare l'interprete irb.

Tutto qui? No: ERb, Ruby on Rails, Puppet, Chef, Vagrand, Metasploit Framework, ...

Ditelo con... l'Assembler

Veramente il linguaggio Assembler avrebbe dovuto essere inserito come primo... ma poiche' non e' molto comune utilizzarlo direttamente, ho preferito ricordarlo solo adesso. Cosi' come non penso di inserire un programma in linguaggio macchina... (ma posso sempre cambiare idea;).
L'Assembler e' un linguaggio molto vicino al processore. Ogni istruzione dell'Assembler corrisponde ad una istruzione riconosciuta dal processore. Percio' vi e' un Assembler per ogni tipologia di processore. Processori CISC hanno centinaia di istruzioni specializzate mentre i RISC hanno tipicamente un set ridotto (ma guadagnano poi con le pipeline, le cache ed il numero maggiore di istruzioni eseguite per clock).

	.cstring
LC0:
	.ascii "Ti amo!\0"
	.text
.globl _main
_main:
LFB3:
	pushq	%rbp
LCFI0:
	movq	%rsp, %rbp
LCFI1:
	subq	$16, %rsp
LCFI2:
	movl	$0, -4(%rbp)
	jmp	L2
L3:
	leaq	LC0(%rip), %rdi
	call	_puts
	incl	-4(%rbp)
L2:
	cmpl	$2, -4(%rbp)
	jle	L3
	leave
	ret
LFE3:
	.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
EH_frame1:
	.set L$set$0,LECIE1-LSCIE1
	.long L$set$0
LSCIE1:
	.long	0x0
	.byte	0x1
	.ascii "zR\0"
	.byte	0x1
	.byte	0x78
	.byte	0x10
	.byte	0x1
	.byte	0x10
	.byte	0xc
	.byte	0x7
	.byte	0x8
	.byte	0x90
	.byte	0x1
	.align 3
LECIE1:
.globl _main.eh
_main.eh:
LSFDE1:
	.set L$set$1,LEFDE1-LASFDE1
	.long L$set$1
LASFDE1:
	.long	LASFDE1-EH_frame1
	.quad	LFB3-.
	.set L$set$2,LFE3-LFB3
	.quad L$set$2
	.byte	0x0
	.byte	0x4
	.set L$set$3,LCFI0-LFB3
	.long L$set$3
	.byte	0xe
	.byte	0x10
	.byte	0x86
	.byte	0x2
	.byte	0x4
	.set L$set$4,LCFI1-LCFI0
	.long L$set$4
	.byte	0xd
	.byte	0x6
	.align 3
LEFDE1:
	.subsections_via_symbols

L'assemblatore su Unix e' as e viene tipicamente richiamato dal compilatore che ha generato il codice (eg cc). Ma naturalmente si puo' scrivere tutto in Assembler partendo da zero!

Il file di esempio riportato e' stato generato di recente su un MAC OS X con cc -s e si sarebbe potuto disassemblare direttamente l'eseguibile con otool o con objdump... ma e' sempre particolarmente poco comprensibile!

Tutto qui? Direi di no... date un'occhiata almeno a il Linguaggio C.

Ditelo con... un 1011.1010.1100.1.0

Alla fine non ho restito... ecco anche un esempio in linguaggio macchina!
Questo linguaggio e' compreso direttamente dal processore e, con qualche difficolta', anche dagli umani che programmano firmware, virus o qualche altro utile oggetto...
Trattandosi del linguaggio compreso direttamente dal processore e' differente per ogni architettura di processore (CISC, RISC), per la dimensione delle istruzioni (8, 16, 32, 64), per modello di processore, ...

0000000 177   E   L   F 001 001 001  \0  \0  \0  \0  \0  \0  \0  \0  \0
0000020 001  \0 003  \0 001  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
0000040 020 001  \0  \0  \0  \0  \0  \0   4  \0  \0  \0  \0  \0   (  \0
0000060  \v  \0  \b  \0   U 211  \0 203  \0  \b 220  \0   E  \0  \0  \0
0000100  \0  \0 211  \0 203   }  \0 002   ~ 002  \0 030 203  \0  \f   h
0000120  \0  \0  \0  \0  \0  \0  \0  \0  \0 203  \0 020 215   E  \0  \0
0000140  \0  \0  \0 220  \0  \0 211  \0  \b  \0  \0  \0  \0  \0  \0  \0
0000160 001  \0  \0  \0   0   1   .   0   1  \0  \0  \0   T   i       a
0000200   m   o   !  \n  \0  \0   G   C   C   :       (   G   N   U   )
0000220       2   .   9   6       2   0   0   0   0   7   3   1       (
0000240   R   e   d       H   a   t       L   i   n   u   x       7   .
0000260   2       2   .   9   6   -   1   2   9   .   7   .   2   )  \0
0000300  \0   .   s   y   m   t   a   b  \0   .   s   t   r   t   a   b
0000320  \0   .   s   h   s   t   r   t   a   b  \0   .   t   e   x   t
0000340  \0   .   r   e   l   .   t   e   x   t  \0   .   d   a   t   a
0000360  \0   .   b   s   s  \0   .   n   o   t   e  \0   .   r   o   d
0000400   a   t   a  \0   .   c   o   m   m   e   n   t  \0  \0  \0  \0
0000420  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
*
0000460  \0  \0  \0  \0  \0  \0  \0  \0 033  \0  \0  \0 001  \0  \0  \0
0000500 006  \0  \0  \0  \0  \0  \0  \0   4  \0  \0  \0   4  \0  \0  \0
0000520  \0  \0  \0  \0  \0  \0  \0  \0 004  \0  \0  \0  \0  \0  \0  \0
...
0001420  \0  \0  \0  \0 003  \0 004  \0 005  \0  \0  \0  \0  \0  \0  \0
0001440  \0  \0  \0  \0  \0  \0 001  \0  \0  \0  \0  \0  \0  \0  \0  \0
0001460  \0  \0  \0  \0 003  \0 006  \0  \0  \0  \0  \0  \0  \0  \0  \0
0001500  \0  \0  \0  \0 003  \0 005  \0  \0  \0  \0  \0  \0  \0  \0  \0
0001520  \0  \0  \0  \0 003  \0  \a  \0 024  \0  \0  \0  \0  \0  \0  \0
0001540   2  \0  \0  \0 022  \0 001  \0 031  \0  \0  \0  \0  \0  \0  \0
0001560  \0  \0  \0  \0 020  \0  \0  \0  \0   p   .   c  \0   g   c   c
0001600   2   _   c   o   m   p   i   l   e   d   .  \0   m   a   i   n
0001620  \0   p   r   i   n   t   f  \0 034  \0  \0  \0 001 006  \0  \0
0001640   !  \0  \0  \0 002  \n  \0  \0

Quanto riportato sopra e' solo il compilato, in realta' deve essere ancora linkato con le librerie e caricato sul sistema (con ld su Unix). Qualche volta capita di agire direttamente sul codice... magari anche quello del sistema operativo! Non e' poi cosi' difficile potrebbe sembrare a prima vista: non c'e' bisogno capire tutto, basta trovare cosa cambiare... buon divertimento con i debugger o con gli editor esadecimali!

Tutto qui? Direi di no... date un'occhiata almeno a Assembler, il linguaggio C, comandi Unix poco noti: adb.

Ditelo con... QCL

Il QCL (Quantum Computation Language) e' uno dei primi linguaggi ad alto livello per i computer quantici. In un computer quantico anziche' utilizzare il bit, che ha gli stati 0 ed 1, vengono utilizzati i qubit che hanno stati quantici che comprendono i valori |0> e |1> ma anche tutti gli stati intermedi sovrapposti. Infatti lo stato di un qubit e' 0 o 1 quando viene letto ma e' molto piu' ampio e rappresentabile da C².
La sintassi di QCL e' molto vicina a quella del linguaggio C con un numero limitato di data type all'interno dell'interprete. Spicca la presenza dei numeri complessi ovviamente utili in questo caso. Ovviamente la parte interessante di QCL sono i qubit accessibili dal linguaggio tramite vettori da dichiarare con il tipo qureg. Sui qubit si lavora con operatori o gate come CNot, Swap, Fanout, Hadamard Gate, ... ma qui diventa difficile da comprendere senza competenze specifiche!
Restiamo quindi con il nostro semplice esempio, utilizzando un numero complesso al posto di un semplice int:

//  TiAmo
//  Esempio di programmazione in QCL

complex c;
for i=0 to 2 { print "Ti amo!"; }

Il linguaggio e' intepretato quindi basta lanciare qcl per eseguire interattivamente lo script.

Tutto qui? No: il linguaggio C, ...

Ditelo con... |0> |1>

Il Quantum Composer e' un interfaccia grafica che permette di sviluppare semplici circuiti che operano su un computer quantico... reale!
Si hanno ha disposizione 5 qubit, con stato iniziale a |0> ed un diverse porte o operatori per modificarne lo stato. Sul Quantum Composer le porte hanno un colore diverso a secondo del tipo di trasformazione.

Ora torniamo al nostro semplice esempio ed otteniamo 11!
Abbiamo utilizzato la porta di Hadamard per impostare gli stati dei qubit Q0 e Q2 portandoli nella condizione massima sovrapposizione. Quindi abbiamo sfruttato la porta CNOT per eseguire una serie di XOR (senza alterare i valori ma ottenendo l'entanglement) e l'operatore X (che e' l'analogo di un NOT). Al termine dell'elaborazione i valori vengono poi misurati. Qualunque sia il valore di Q0 e di Q2 i valori registrati su Q3 e di Q4 saranno sempre 11.
Poiche' c'era un po' di spazio... abbiamo utilizzato anche altri operatori disponibili su Q4 prima dell'impostazione finale.

Una volta preparato il programma puo' essere simulato oppure inviato al Quantum Computer che provvedera' ad eseguirlo! [NdE L'esempio scelto non e' adatto all'esecuzione reale ma puo' essere solo simulato perche' non rispetta gli attuali limiti fisici di connessione per la porta CNOT]

Tutto qui? Si, per il momento ...

Ditelo con... TXT

Il TXT non e' un linguaggio ma un formato. L'ho riportato lo stesso perche'... l'avevo dimenticato! Ma giustamente me lo hanno ricordato ed e' la base con cui sono scritti la maggioranza dei testi e dei linguaggi.

Ti amo!
TI AMO!
¡oɯɐ ıʇ
eof

Per visualizzarlo? Basta un cat tiamo.txt
L'EOF al fondo indica l'End Of File e mi e' piaciuto lasciarlo perche' spesso si visualizzano come testo programmi o dati alla ricerca di caratteri alieni con strani nomi come EOL, CR, DEL, 0x00, ...

Tutto qui? Noo: ASCII, Unicode, UTF-8, ...

Ditelo con... PDF

Il PDF non e' un linguaggio ma un formato. L'ho riportato lo stesso perche' e' molto diffuso per la produzione di documenti di alta qualita' e perche' il numero di librerie, programmi, ambienti che lo trattano e' molto elevato.

%PDF-1.4
%äüöß
2 0 obj
<< /Length 3 0 R
   /Filter /FlateDecode
>>
stream
xú≈ª
¬@E˚Ö˝á[[lffl        ,)í(X,¯>¿B0çÔ¿U:äÅ3èo)^ê“çW”™¡|≈y’

Beh il formato e' binario!

Tutto qui? Si: ...

Ditelo con... QR

QR non e' un linguaggio di programmazione ma un codice. Il QR code e' una matrice bidimensionale progettata per una veloce lettura da parte di dispositivi automatici. QR consente di rappresentare numeri, stringhe di caratteri, URL, numeri, ... con diversi livelli di correzione d'errore (da L con il 7% a H con il 30%), codifiche (eg. numeri, stringhe alfanumeriche, ...), dimensioni (curiosamente chiamate versioni: dalla versione 1 21x21 alla versione 40 177x177).
Anche se e' solo un codice nulla gli impedisce di esprimersi in modo romantico! Ecco il solito esempio...

Anche se inizialmente progettato per l'industria automobilistica il QR si e' rapidamente diffuso in molti altri ambiti. Un utilizzo molto comune e' per codificare URL riconosciuti automaticamente da programmi su dispositivi Mobile. Infatti sui cellulari, anche se dotati di tastiera, l'introduzione dei caratteri necessari a raggiungere un sito internet e' sempre difficoltosa. Invece, con un'opportuna applicazione, basta utilizzare la fotocamera per riconoscere immediatamente il codice e raggiungere il sito voluto.
Tutto qui? Si!

Ditelo con... Markdown

Markdown e' linguaggio che consente di utilizzare gli stili dell'HTML (titoli, bold, liste, tabelle) con una sintassi semplicissima.
Nato per commentare i testi in GitHub e' utilizzato da moltissimi ambienti sul Web.

In generale si scrive un testo e si usano alcuni caratteri speciali (*, #, `, -) singoli o ripetuti per indicare le formattazioni. Il risultato e' un testo facilmente leggibile da terminale ma graficamente valido se pubblicato e letto con un browser.
Anche se e' solo un codice e non un completo linguaggio di programmazione, nulla gli impedisce di esprimersi in modo romantico! Ecco il solito esempio...

**Ti amo!** **Ti amo!** **Ti amo!** :kiss:

Tipicamente i file in formato Markdown hanno il suffisso .md
Tutto qui? No: HTML, ...!

Ditelo con... Mermaid

Il tool Mermaid utilizza un formato che, con una sintassi molto semplice, consente di realizzare diagrammi anche compessi.
Mermaid ha una sintassi simile al Markdown e consente di semplificare notevolmente la documentazione quando richiede componenti grafiche. Risulta cosi' molto semplice ottenere grafici da programmi e script.

E' possibile generare diversi tipi di diagrammi: Flow Chart, Sequence Diagram, Class Diagram, State Diagram, Gantt, Entity-Relationship, Torte, ... tutti costituiti da un semplice testo.
Come esempio rappresentiamo un flow chart per il nostro programma e vediamo come viene visualizzato in una pagina HTML:

graph TD
  A((Begin)) --> B[N=0]
  B --> C{N>2 ?}
  C -->|Yes| F((End))
  C -->|No| D[N=N+1]
  D --> E(Print 'Ti amo! fa:fa-heart ')
  E --> C

Dal punto di vista tecnico mermaid e' uno script JavaScript e puo' essere facilmente integrato in una pagina HTML o incluso in un'applicazione.
Tutto qui? No: Markdown, HTML, JavaScript, ...!

Ditelo con... Lua

Lua e' un linguaggio di programmazione embedded di tipo procedurale. Poiche' e' un linguaggio embedded non c'e' nessun main ma opera solo all'interno di un altro programma. Lua e' fornito come libreria C da linkare con l'applicazione ospite.
L'applicazione ospite puo' leggere e scrivere le variabili Lua, puo' eseguire del codice, puo' registrare funzioni C da far eseguire a Lua... Le possibilita' sono molteplici. La libreria e' di piccole dimensioni e la licenza con cui e' distribuita e' molto aperta. Il linguaggio Lua e' quindi sfruttato in ambienti software complessi (che consentono una programmazione da parte degli utenti) ma anche su appliance e console per giochi.

-- Esempio con Lua

i = 0
      while i < 3 do
        print("Ti amo!")
        i = i+1
      end

Nell'esempio viene eseguita la nostra simpatica stampa tre volte... pero' poteva anche spostare tre volte un braccio di un robot, assegnare tre crediti in un video gioco o bloccare tre pacchetti su un'interfaccia di rete! Ma tutto questo puo' funzionare solo all'interno di un altro programma.

Ecco una semplice applicazione che richiama l'interprete Lua:

/* Progamma in linguaggio C che richiama Lua */

#include 
#include "lua.h"             
#include "lualib.h"          

int main (int argc, char *argv[])
{
 char line[BUFSIZ];
 iolib_open();             
 strlib_open();             
 mathlib_open();            

 while (gets(line) != 0)
   lua_dostring(line);
}

Tutto qui? No: linguaggio C, MySQL Proxy, decine e decine di giochi, Snort, NMAP, Roblox, ...

Ditelo con... Rockstar

Rockstar e' un linguaggio di programmazione le cui specifiche sono nate quasi per scherzo ma che ha subito suscitato interesse ed e' stato quindi realizzato veramente.

Ci sono linguaggi per fare le ricette? Rockstar e' il primo linguaggio Turing completo i cui programmi sono testi di canzoni con una preferenza per l'Hard Rock!

(Lyrics by meo)

Romeo is shy.
While Romeo ain't nothing
 whisper "Ti amo!"
Knock it down!

Per eseguire il programma Rockstar e' disponibile Satriani, un interprete JavaScript [NdA non temete: non bisogna esse bravi come Satriani per comprendere il linguaggio].

Tutto qui? No: JavaScript, Chef, ...

Ambienti

Quando si lavora su un sistema, sia per sviluppare programmi che per utilizzarli, si dispone sempre di un ambiente. Questi ambienti possono essere molto semplici oppure consentire loro stessi una sorta di programmazione. In alcuni casi, poiche' l'ambiente rappresenta il "guscio" con cui si muove l'utente, vengono chiamati shell.

Gli ambienti su cui ho preparato un esempio sono: sh (Bourne shell), ksh (Korn shell), csh (C shell), bash (Bourne Again shell), cowsay, asciinema, awk, MS-DOS, WSH, AppleScript, sh (speaking on MAC), Tcl, Tk, expect, REXX, CISCO-IOS, FireWall-1 INSPECT, Arduino, Raspberry, ...

Ditelo con... sh (Bourne shell)

Una shell e' un'interprete di comandi che legge i comandi impartiti dall'utente sulla tastiera e li esegue sul sistema operativo. La Bourne shell e' una delle shell disponibili sui sistemi Unix. Tra tutte e' la piu' semplice e la piu' utilizzata per la creazione di script (che diventano a volte veri e propri programmi).
La Bourne shell utilizza naturalmente un interprete ed il linguaggio non e' complesso anche se vi sono alcune particolarita' con caratteri quali gli apici, gli asterischi, il trattamento delle variabili, ...

# Esempio in Bourne shell

i=0
while [ $i -lt 3 ]
do
        echo "Ti Amo!"
        i=`expr $i + 1`
done    

Certo sarebbe stato piu' semplice scrivere semplicemente tre echo ma sicuramente meno divertente...
Un'evoluzione della Bourne shell e' la Korn shell. Da punto di vista della programmazione degli script non vi sono particolari differenze. Ma non anticipiamo...

Tutto qui? No: alias, variabili, caratteri "Jolly", background/foreground, ... Riferimenti: ...

Ditelo con... ksh (Korn shell)

La Korn shell e' un interprete di comandi Unix. Si tratta di un'evoluzione della Bourne shell. Vi sono tuttavia diverse estensioni. Oltre ad alcune estensioni sintattiche la Korn shell offre maggiori possibilita' di editing dei comandi e nella gestione dei job (comandi sottomessi al sistema).
Il linguaggio della Korn shell e' molto vicino a quella della Bourne shell.

# Esempio in korn shell

i=0
while ( test i -lt 3 )
do
        echo "Ti Amo!"
        i=`expr $i + 1`
done

L'esempio utilizzato con la Bourne shell non darebbe errore sintattico, ma andrebbe in loop. Invece l'esempio riportato in precedenza per la Bourne shell funziona correttamente anche con la Korn shell.
Un altro esempio...

# Esempio in korn shell

integer i=0
while (( i < 3 ))
do
        echo "Ti Amo!"
        i=i+1
done

Tutto qui? No: history, gestione dei job, programmazione, ... Riferimenti: ...

Ditelo con... csh (C shell)

Anche la csh e' una shell Unix. Poiche' la sua sintassi e' differente da quella della Bourne shell (e piu' vicina a quella del linguaggio C) mi e' parso opportuno riportarne un esempio...

La c-shell offre, analogamente alla Korn shell, diverse possibilita' di editing dei comandi, history, ... funzioni molto comode per gli utenti interattivi.

# Esempio in C-shell

set i=0
while  ( $i < 3 )
        set i=`expr $i + 1`
        echo "Ti amo!"
end

Tutto qui? No: history, gestione dei job, programmazione, ... Riferimenti: ...

Ditelo con... bash (Bourne Again)

La bash e' ancora un'altra shell!
In realta' non c'e' piu' molto da dire sulle shell Unix, ma non volevo dimenticare la bash che e' quella piu' utilizzata su Linux e quindi diffusissima. Caratteristiche principali? Facile (eg. funzionano i tasti con le frecce ed i colori!) e potente (sintassi Bourne Shell + Korn Shell).
L'esempio di programmazione ve lo risparmio: e' uguale ai precedenti.

Tutto qui? No: Shell features, ...

Ditelo con... cowsay

cowsay e' realmente una pietra miliare nello sviluppo di Unix/Linux come lo yacc o il banner (in effetti forse piu' come quest'ultimo :)
Da provare anche con il parametro -f (eg -f kiss).

i=0; while [ $i -lt 3 ]; do echo 'Ti amo!'; i=`expr $i + 1`; done | cowsay
 _________________________ 
< Ti amo! Ti amo! Ti amo! >
 ------------------------- 
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Tutto qui? No comment!

Ditelo con... asciinema

asciinema consente di registrare una sessione di terminale e replicarne il contenuto su un browser.

Usiamolo per il nostro semplice esempio:

Ditelo con... awk

L'awk e' uno strano linguaggio che consente di analizzare e gestire file di testo. E' molto utilizzato per convertire file di testo e/o effettuare calcoli e conteggi sui valori contenuti in un file. L'awk e' distribuito, come tantissimi altri programmi di utilita', su tutte le distribuzioni standard di Unix.
Si tratta di un linguaggio interpretato con una sintassi che prevede una sequenza di pattern ed azioni. Quando il pattern viene riconosciuto nell'input l'azione viene eseguita.

echo | awk 'BEGIN{}{for(i=0;i<3;i++) printf("Ti amo!")}END{printf("Ti amo!\n")}'

In realta' il "programma" in awk e' quello tra apici, il resto e' solo il richiamo da una shell... (NdA il BEGIN non serviva, e neanche l'END in verita' ma cosi' il programma e' diventato un poco piu' lungo).

Tutto qui? No! ...

Ditelo con... MS-DOS

Veramente l'MS-DOS vorrebbe essere un sistema operativo e non un linguaggio... Il suo interprete di comandi e' il COMMAND.COM. Si tratta di una shell limitata ma che consente comunque di scrivere e lanciare file di comandi.

@echo off

echo Ti amo!
echo Ti amo!
echo Ti amo!

Il primo comando evita che venga riportato a video il comando eseguito. Deve essere notato che la shell del MS-DOS e' piuttosto povera e quindi non e' stato possibile utilizzare cicli, variabili, ... almeno nell'esempio specifico.

Per eseguire il "programma" i comandi debbono essere inseriti in un file (ad esempio DIMMELO.BAT, il suffisso e' obbligatorio ed e' una abbreviazione di BATCH). Quindi va lanciato semplicemente scrivendo "DIMMELO".

Tutto qui? Praticamente si! Riferimenti: ...

Ditelo con... wsh

WSH sta per Windows Scripting Host ed e' il nuovo ambiente di scripting di Microsoft. Sostituisce i vecchi file .BAT e' indipendente dal linguaggio ed e' molto piu' potente.
Possono essere utilizzati piu' linguaggi. Tra tutti quello piu' comunemente utilizzato e' VBScript (ma sono anche utilizzabili Java Script e, tramite moduli di terze parti, Perl, Phyton). WSH fornisce una serie di oggetti e di metodi per interagire con il sistema...

for i=1 to 3
  wscript.echo "Ti amo!"
next

E' sufficiente scrivere il programma in un file dal nome dimmelo.vbs e' questo e' immediatamente utilizzabile (il suffisso VBS e' registrato).

La potenza dell'ambiente e' notevole... nell'esempio seguente il programma parla!

Dim strText
'Dimmelo
strText = "Ti amo!"
Set Sapi = Wscript.CreateObject("SAPI.SpVoice")

for i=1 to 3
  Sapi.speak strText
next

Tutto qui? No: Windows Scripting Host ...

Ditelo con... AppleScript

L'AppleScript e' un linguaggio con una sintassi molto vicina all'inglese che consente di inviare comandi al sistema ed alle applicazioni Mac.

Ogni elemento trattabile e' un oggetto e le applicazioni Cocoa sono molto ricche di funzionalita' richiamabili da AppleScript. I comandi sono indirizzati alle applicazioni con una sintassi molto vicina alla lingua inglese: tell application "Finder" to ....
Sono disponibili variabili, istruzioni condizionali, loop, ...
Il linguaggio e' interpretato e viene salvato in formato precompilato.

-- Dimmelo!
set message to ""repeat 3 times	set message to message & "Ti amo!
"end repeatdisplay dialog message buttons "OK" default button "OK"

L'utility AppleScript Editor permette di scrivere o registrare gli script che possono essere salvati come file .scrpt o come applicazioni .app

La potenza dell'ambiente e' notevole... nell'esempio seguente il programma parla!

# Dimmelo con parole tue!repeat 3 times	say "Ti amo!"end repeat

Tutto qui? Per ora si, poi si vedra'...

Ditelo con... sh (ancora? "parla davvero!" su Mac OS X)

Un programma in Bourne shell gira su un qualsiasi Unix. Quindi anche su Mac OS X! MAC OS X e' l'evoluto sistema operativo di Apple (e' uno Unix) utilizzato sui sistemi MAC. Tra le molte funzioni disponibili e' presente il TTS (Text To Speach).

# Esempio in Bourne shell con TTS (su MAC)

for i in 1 2 3
do
    say -v vicki Ti amo\!
done 

Nulla di particolare... solo un ciclo for ed programma di TTS utilizzabile da linea di comando.

Tutto qui? No: ci sono molti altri esempi di TTS come Windows Script, Apple Script,...

Ditelo con... Tcl

Tcl (Tool Command Language) e' un semplice e potente linguaggio intepretato.

Tcl e' utilizzato principalmente per eseguire comandi. In effetti ogni istruzione e' un comando in notazione polacca prefissa.
Non sapete cosa vuol dire? La notazione e' precisa: puo' essere prefissa, infissa e postfissa. Insomma una polacca da davanti, in mezzo e da dietro. Naturalmente stiamo parlando di operatori ed argomenti!

Tcl ha un numero notevolissimo di estensioni tra cui la piu' nota e' Tk che implementa la grafica.

# Script Tcl

for {set i 0} {$i < 3} {incr i 1} {
 puts "Ti amo!\r"
}

Per eseguirlo? Basta scrivere il contenuto dell'esempio nel file dimmelo.tcl ed eseguirlo con tclsh < dimmelo.tcl

Tutto qui? si: ... per ora!

Ditelo con... Tk

Tk e' il toolkit grafico di Tcl. Poiche' i comandi Tk sono relativi solo alla parte grafica e' necessaria una base di linguaggio che e' fornita tipicamente da Tcl. Quindi la sigla piu' utilizzata e corretta e' Tcl/Tk

Tk ha un'ampia scelta oggetti grafici o widget (eg. button label menu ...) da personalizzare e con cui costruire l'interfaccia utente. Per visualizzare quanto definito si utilizza il comando pack.
Tk e' indipendente dalla piattaforma e gli script Tcl/Tk possono essere eseguiti indifferentemente su Unix, Windows, Linux, ...

# Script Tcl/Tk

set dimmi ""
for {set i 0} {$i < 3} {incr i 1} {
 append dimmi "Ti amo!\n"
}
pack [button .h -text $dimmi -command exit]

Per eseguirlo? Basta scrivere il contenuto dell'esempio nel file dimmelo.tk ed eseguirlo con wish < dimmelo.tk

Tutto qui? No: Tcl, Tkinter, ...

Ditelo con... Expect

Expect e' un semplice interprete che serve a parlare con altri programmi interattivi eseguendo uno script. Ad esempio e' possibile programmare uno script Expect per lanciare una sessione fsck e rispondere in automatico alle varie domande interattive. L'altro utilizzo molto comune e' quello di fare eseguire ad Expect le fasi iniziali di un login.

Expect viene tipicamente programmato con una sequenza di expect e send per dialogare e quindi vengono eseguiti spawn per lanciare comandi e interact per interagire da terminale. Gli altri comandi utilizzabili sono quelli del Tcl (Tool Command Language) che e' molto potente (eg. set if for while ...).

#!/usr/bin/expect -f
# Script Expect

set timeout 20
set user [lindex $argv 0]
set password [lindex $argv 1]
spawn su $user
expect "Password:"
send "$password\r";

expect "$"
send "vi dimmelo.txt\ri"
for {set i 0} {$i < 3} {incr i 1} {
 send "Ti amo!\r"
}
send "\033:wq\r"

interact

Cosa combina questo script? Beh, questa volta ho fatto fare qualcosetta in piu': login su un utente e creazione di un file!
Per eseguirlo? Basta scrivere il contenuto dell'esempio nel file dimmelo, renderlo eseguibile con chmod +x dimmelo ed eseguirlo con ./dimmelo utente XXX

Tutto qui? No: Tcl, ...

Ditelo con... REXX

REXX (REstructured eXtended eXecutor) e' un linguaggio interpretato sviluppato da IBM ma di cui ora esistono diversi interpreti, anche di pubblico dominio. Inizialmente nato come linguaggio di scripting per gli ambienti IBM Mainframe e' stato sucessivamente portato su diverse piattaforme (eg. palmari) ed ha una buona diffusione.

REXX ha una sintassi semplice e facilmente comprensibile, il che consente un apprendimento rapido ed una veloce realizzazione di script e programmi.
REXX e' considerato il precursore di diversi liguaggi di scripting come il Tcl e Python ed e' in continua evoluzione (eg. ooRexx: Open Object REXX),

/* Esempio REXX */        
                  
DO I=1 TO 3       
   SAY 'TI AMO !' 
END               
                  
EXIT  

Il "commento" iniziale e' importante. Consente al TSO di lanciare l'interprete corretto!

Tutto qui? Beh, si!

Ditelo con... l'IOS

L'IOS e' il sistema operativo proprietario della Cisco. Ma la Cisco non fa i router? Certo! Infatti e' il sistema operativo di router, di switching-hub, ... insomma di strane apparecchiature che servono per collegare tra loro reti di computer.
A questi sistemi, benche' siano molto complessi e potenti, non servono shell sofisticate ed ambienti di programmazione. Quindi le possibilita' di utilizzare l'IOS per scrivere un programmino sono piuttosto limitate. Ma non dobbiamo farci limitare: l'amore puo' ogni cosa!? In qualche maniera manderemo il nostro messaggio.

banner exec #
Ti amo!
Ti amo!
Ti amo! #

L'interprete dei comandi dell'IOS e' l'EXEC. Chiaramente non e' molto potente... Nell'esempio l'abbiamo semplicemente utilizzato per definire il prompt che presenta il nostro messaggio.

Per effettuare questa programmazione (ma sarebbe piu' corretto chiamarla configurazione) e' necessario collegarsi all'apparecchiatura, entrare in modalita' privilegiata con il comando di enable (naturalmente bisogna conoscere la password), entrare in modalita' di configurazione da terminale con il comando conf t, introdurre i comandi dell'esempio e terminare con Ctrl-Z.

Tutto qui? No: ... ma per adesso puo' bastare!

Ditelo con... INSPECT

L'INSPECT e' il linguaggio di scripting del firewall FireWall-1 prodotto da CheckPoint. Sapete tutti cos'e' un firewall vero? Beh, ve lo dico lo stesso! Un firewall viene posto tra due o piu' reti per controllare tutti i messaggi che circolano proteggendo i sistemi da accessi non desiderati. Un firewall viene programmato mediante semplici regole che definiscono quali servizi di rete sono abilitati ed a quali utenti/sistemi/reti.
Con l'INSPECT si possono programmare le regole del firewall per realizzare controlli particolarmente complessi e sofisticati. Si tratta di un linguaggio potente, con una sintassi molto simile a quella del C o del C++. Ma certo non adatto ad inviare messaggi: infatti il suo compito e' quello di bloccarli!

#include "fwui_head.def
memo=format{
        <"src", ipaddr, src>
        <"text", string, "Ti amo!">
        };
accept                                         // Action
        ( tcp ),                                 // Service
        ( ip_src = 194.243.246.69 ),             // Source
        LOG (memo, LOG_NOALERT, 69 );            // Track
      

Con l'INSPECT vengono creati degli INSPECTION SCRIPT per la programmazione delle regole del firewall. Ogni regola e' composta da un'azione (eg. accettare un messaggio) che viene eseguita se le condizioni della regola sono soddisfatte (eg. viene richiesto un servizio TCP e l'indirizzo sorgente e' uno specifico indirizzo). Una regola puo' essere controllata con un logging specifico. Nel nostro caso abbiamo utilizzato un trucco. Abbiamo creato un formato di log specifico ed al passaggio di ogni pacchetto riportiamo il nostro messaggio.

E' raro dover programmare in INSPECT... ma mai dire mai! In ogni caso gli script vengono compilati dal compilatore di FireWall-1 e quindi eseguiti dal modulo runtime.

Tutto qui? No: ... ma per adesso puo' bastare!

Ditelo con... Arduino

Arduino e' una scheda elettronica che contiene un potente microcontrollore programmabile in modo semplice. Tutto il disegno di Arduino e' Open Source: sia per la parte Hardware che Software.
Oltre a diversi tipi di schede elettroniche, Arduino include anche un completo ambiente di sviluppo (IDE) che gira su un personal computer (MS-Windows, Linux, MAC) con il quale scrivere i programmi (sketch) da caricare sulle schede Arduino.
Il linguaggio utilizzato da Arduino e' chiamato Wire ed ha una sintassi molto vicina a quella del linguaggio C (con qualche estensione ad oggetti come in C++). La programmazione richiede la definizione di due funzioni: la funzione setup() che viene eseguita inizialmente e tipicamente effettua la configurazione iniziale e la funzione loop() che viene eseguita in ciclo.

/*
  TiAmo
  Esempio di programmazione della scheda Arduino
  Legge il valore di un sensore. Se e' superiore a 4V scrive 3 volte "Ti amo!" facendo lampeggiare un led.
*/
int led = 13;
int i = 0;

void setup() {                
  pinMode(led, OUTPUT);
  Serial.begin(9600);    /* 115200 on ArduinoBT */
}

void loop() {
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.0 / 1023.0);

  if (voltage > 4.0) {
    for (i=0; i<3; i++) {
      digitalWrite(led, HIGH);  
      delay(1000);             
      digitalWrite(led, LOW);    
      delay(1000);
      Serial.println("Ti amo!");
    }
  }            
}

Una volta scritto il programma questo viene compilato ed inviato sulla scheda premendo il tasto corrispondente sull'interfaccia di programmazione. La comunicazione con la scheda e' di tipo seriale e, nelle schede piu' recenti, effettuata sulla connessione USB o Ethernet.

Tutto qui? No: il linguaggio C, C++, ...

Ditelo con... Raspberry

Raspberry e' un computer completo realizzato su una semplice piccola scheda. Essendo un computer ha bisogno di un sistema operativo e quindi puo' ospitare ogni tipo di software. L'ho inserito in questa sezione vicino ad Arduino perche' anche se sono oggetti profondamente diversi possono essere utilizzati per progetti simili nell'IOT, nell'elettronica, nell'automazione, ...

Nell'esempio infatti utilizzeremo alcuni dei 40 pin del GPIO (general-purpose input/output) con la libreria GPIO Zero di Python che e' installata per default nel sistema operativo Raspberry Pi OS.

'''
TiAmo
Esempio di utilizzo del GPIO sul computer Raspberry con la libreria Python GPIO Zero.
Legge il valore su un PIN. Se e' alto scrive 3 volte "Ti amo!" e fa lampeggiare un led.
'''

from gpiozero import LED, Button
from time import sleep

led = LED(13)
button = Button(2)
int i = 0;

while True:
    if button.is_pressed:
         for i in range(3):
             print "Ti amo!"
             led.on()
             sleep(1)
             led.off()
             sleep(1)
    else:
        led.off()

Una volta scritto il programma nel file dimmelo.py e realizzati i collegamenti elettrici basta lanciare l'esecuzione con il comando python dimmelo.py.

Tutto qui? No: Python, Arduino, ...

Architetture

Non e' solo importante scrivere un programma, ma questo deve poter comunicare con altri programmi, con il sistema, con gli utenti, ... Questi aspetti vengono tenuti in conto nell'architettura. Da sempre i sistemi informativi hanno utilizzato architetture complesse ed implementate su piu' livelli. Si e' sempre parlato di sistemi a cipolla, di applicazioni a due/tre/quattro/X livelli, di strati, di API, ... Tuttavia ultimamente, con la forte crescita tecnologica delle telecomunicazioni e di Internet, questo aspetto ha assunto un'importanza ancora maggiore.

Non e' raro "smarrirsi" e non capire dove viene realizzata una certa funzione. Forse e' un servlet sul Web Server oppure puo' essere un trigger sul DB server, una business logic implementata nell'application server, essere eseguita sul browser, ...

Relativamente alle architetture presentiamo quelle apparentemente piu' tradizionali per l'accesso alle basi dati ( ISAM, MySQL API/C, Oracle Pro*C, Oracle Pro*Cobol, JDBC, MongoDB, CouchDB, neo4j, Pentaho/Kettle, ...), alcune grafiche e quindi graziose ( Curses, X-Windows, motif, Tkinter, GTK, Cocoa, ...), quelle piu' recenti e simpatiche su Internet ( socket - Client, socket - Server, socket - Client (PL-SQL), HTML, XML, SGML, XHTML, HTML5, CGI, LAMP, LAPO, LAPP, AngularJS, MEAN, Applet Java, RMI, JavaScript, p5.js, VB Script, Servlet, JSP, EJB, Portlet (JSR 168), ASP, Node.js, Node-RED, MATLAB App Designer, Stitch, Roblox, Telegram Bot, Motion AI Bot, Solidity, Cache'/SOAP, PHP/SOAP, COM/ActiveX, ...), per il mondo @&. Mobile, che per me e' un bel ODI ET AMO ( T9, WAP, Android SDK, Zlango, ...), quelle un poco particolari ( Cartridge PL-SQL, External Procedure Oracle, UML, Grinder, ...), ...

Ditelo con... l'ISAM

L'ISAM (Indexed Sequential Access Method) e' un metodo di accesso ai dati che ne permette la memorizzazione e la ricerca efficienti.
Nell'antico mondo Mainframe l'ISAM e' una delle strutture dati supportate dal sistema mentre su altri ambienti e' invece disponibile come libreria. In questo ultimo caso i programmi vengono realizzati richiamando l'API (Application Program Interface) e vengono poi linkati con la relativa libreria.
Spesso l'ISAM e' sfruttato da un RDBMS (eg. C-ISAM per Informix, MyISAM per MySQL) per la memorizzazione dei dati e non viene "visto" da utenti e programmatori che utilizzano linguaggi di piu' alto livello come l'SQL... Pero' c'e' sempre qualcuno che lavora nel sottosuolo, come il sottoscritto, a cui puo' capitare di vederlo!

#include 

char data[30];
struct keydesc key;

main()
{
int cc,fd,i;

cc = fd = isopen("base", ISAUTOLOCK+ ISOUTPUT);
if (cc < 0)
   exit(1);

for(i=0;i<30;i++)
  data[i]=' ';

for(i=0;i<3;i++)
   {
   strcpy(data, "Ti amo!");
   cc = iswrite(fd, data);
   }
isclose(fd);
}

L'esempio e' in C e richiede quindi una compilazione con cc dimmelo.c -lisam -lm.
L'ISAM e' una libreria molto efficiente ma di basso livello... non solo mancano metodi di ricerca complessi come le join, al programmatore tocca anche l'onere di mettere i campi nelle posizioni corrette del record scrivendoli byte per byte!

Tutto qui? No: linguaggio C, SQL, ...
Sono passati piu' di vent'anni ed i metodi di accesso per chiave sono tornati di attualita'. Molti database NoSQL e Big Data utilizzano metodi di accesso simili (key/value)!

Ditelo con... C/API MySQL

Per accedere ad una base dati sono disponibili diversi programmi ed interfacce. Una delle piu' comuni e piu' utilizzate, soprattutto quando le prestazioni sono l'esigenza principale, e' quella di un API (Application Program Interface) verso un linguaggio procedurale compilabile. Cosa meglio del linguaggio C? Beh, qualcuno risponderebbe il Cobol ma avrebbe torto!
Come architettura e' molto semplice: l'applicazione in C richiede i servizi verso il DB Server passando gli statement SQL attraverso le chiamate a funzione dell'API. Queste operano in rete su un protocollo propritario Client/Server, per avere la massima flessibilita', oppure richiamano funzioni linkate nello stesso programma per ottenere il massimo della velocita' di accesso ai dati.

/* dimmelo.c n MySQL API */

#include 
#include "mysql.h"

char    username[40];
char    passwd[40];
char    hostname[40];
char    db_name[40];
char    query[256];
MYSQL m;
int             i;

main()
{
strcpy(username, "root");
strcpy(passwd, "");
strcpy(hostname, "localhost");
strcpy(db_name, "test");

mysql_init(&m);

if (!mysql_real_connect(&m, hostname, username, passwd, db_name, 0,NULL,0))
        {
        fprintf(stderr, "Error in connect: %s\n",
                        mysql_error(&m));
        exit(1);
        }

for (i=0;i<3;i++)
        {
        sprintf(query, "INSERT INTO dimmelo(testo) VALUES ('Ti Amo!')");
        if (mysql_query(&m, query))
                { fprintf(stderr, "Error in INSERT: %s\n", mysql_error(&m)); }

        mysql_commit(&m);
        }
mysql_close(&m);

exit(0);
}

Si tratta di un semplice programma C che inserisce tre righe in una tabella della base dati. Per compilare il programma basta utilizzare il semplice comando cc -o dimmelo -I/usr/include/mysql -mcpu=i486 -fno-strength-reduce dimmelo.c -L/usr/lib/mysql -lmysqlclient -lz -lcrypt -lnsl -lm -lc -lnss_files -lnss_dns -lresolv -lc -lnss_files -lnss_dns -lresolv Sembra difficile... ma sono solo un po' di librerie (e poi con mysql_config si ottiene l'elenco completo dei parametri da utilizzare).

Quanto a MySQL e' il puo' diffuso DB relazionale Free Software, ma sarebbe un lungo discorso...

Tutto qui? No: SQL, Pro*C, MySQL, ...

Ditelo con... il Pro*C

L'RDBMS Oracle, come MySQL, fornisce un'interfaccia API per i programmatori: le OCI (Oracle Call Interface). Tuttavia l'utilizzo di un API funzionale per interfacciarsi ad una base dati presenta alcune difficolta'. E' necessario trattare con il linguaggio di programmazione tutti i tipi di dati, le conversioni, ... per richiamare in modo corretto l'SQL riconosciuto dall'RDBMS. Una modalita' piu' semplice per i programmatori e' quella di utilizzare un linguaggio procedurale "arricchito" che consenta di utilizzare liberamente gli Statement SQL nel codice. Quindi una fase di precompilazione trasformera' il codice in sorgente C (o Cobol, ...) compilabile con le solite modalita'.

Il Pro*C e' il precompilatore fornito da Oracle (il piu' noto e diffuso DB relazionale commerciale) per utilizzare l'SQL in programmi C. A parte la modalita' di compilazione l'architettura e' quella di un semplice Client/Server...

/* Dimmelo.pc Esempio in Pro*C */

#include 
#include 
#include 

EXEC SQL BEGIN DECLARE SECTION;
VARCHAR         username[40];
VARCHAR         passwd[40];
VARCHAR         connstr[40];
EXEC SQL END DECLARE SECTION;

int                i;

void sqlerror();

main(argc, argv)
int argc;
char **argv;
{
        strcpy(username.arr, "SCOTT"); 
        username.len = strlen(username.arr);
        strcpy(passwd.arr, "TIGER");  
        passwd.len = strlen(passwd.arr);
        strcpy(connstr.arr, "ORCL");
        connstr.len = strlen(connstr.arr);
 
        EXEC SQL WHENEVER SQLERROR DO sqlerror();
        EXEC SQL CONNECT :username 
                IDENTIFIED BY :passwd
                USING :connstr;

        for (i=0;i<3;i++)
                {
                EXEC SQL INSERT INTO dimmelo(testo) VALUES ('Ti Amo!');
                }
        EXEC SQL COMMIT WORK RELEASE;
        exit(0);

}

void sqlerror()
{
        EXEC SQL WHENEVER SQLERROR CONTINUE;
        printf("\nORACLE error detected:\n");
        printf("\n% .70s \n", sqlca.sqlerrm.sqlerrmc);
        EXEC SQL ROLLBACK RELEASE;
        exit(1);
}

L'utilizzo dei cursori, delle Host variables, conversioni, ... e' piu' semplice con il Pro*C. Per compilare basta costruirsi un bel makefile (partendo dagli esempi, altrimenti non c'e' speranza!) ed il gioco e' fatto!

Tutto qui? No: SQL, ...

Ditelo con... il Pro*Cobol

Lo so, non ho mai scritto un programma Cobol per Oracle...
Ma ne ho compilati veramente tanti!

Non so il perche', ma per qualche strana ragione chi scriveva in Cobol non era in grado di compilare i propri programmi su Unix e con Oracle. Cosi' intervenivo io che, conoscendo il C e le regole di base della compilazione e del link dei programmi, riuscivo a mettere insieme librerie, runtime e programmi in un eseguibile finale.
In realta' non sempre si trattava di un eseguibile, ma spesso di un runtime (il famigerato rtsora) in grado di lanciare i programmi precompilati... comunque funzionava!

Tutto qui? No: SQL, Pro*C, ...

Ditelo con... JDBC

JDBC e' un API per interfacciare i database da applicazioni Java.

/**
        Esempio di programma in linguaggio Java
        con accesso ad un DB tramite JDBC
*/

import java.sql.*;
public class Dimmelo 
{
    public static void main( String[] args ) throws SQLException
    {
        int i;

        DriverManager.registerDriver (new oracle.jdbc.driver.OracleDriver());
        Connection conn = DriverManager.getConnection( 
            "jdbc:oracle:thin:@127.0.0.1:1521:orcl",
            "SCOTT",
            "TIGER" );
        Statement stmt = conn.createStatement();

        for (i=0; i<3; i++)                          
            stmt.executeUpdate( "INSERT INTO dimmelo(testo) VALUES('Ti Amo!')" );

        stmt.executeUpdate( "COMMIT" );
    }
}

Nell'esempio viene realizzato in Java il semplice esempio gia' visto in SQL.
Per la compilazione vanno seguite i passi di un normale programma Java, con l'avvertenza di avere definito il CLASSPATH con il driver (eg. export CLASSPATH=some_path/ojdbc6.jar). Naturalmente non e' possibile descrivere le molte possibilita' offerte dal JDBC: prepared statement, cursori, scrollable cursor, ... verso tutti i DB che hanno un driver tra cui Oracle, MySQL, PostgreSQL, ... praticamente tutti. Ma sono tutti come uno se li puo' aspettare!

Tutto qui? No: Java, SQL, OCI, ...

Ditelo con... MongoDB

MongoDB e' un database non-SQL. La memorizzazione e presentazione dei dati sono strutturate come documenti (in formato JSON) e non sotto forma di tabelle come avviene nelle basi dati relazionali. Si tratta di una base dati che supporta in modo nativo l'indicizzazione, le query dinamiche (fin qui tutto normale), la replicazione automatica, l'High Availability, lo Sharding, la gestione dei dati non strutturati (e questo invece e' sicuramente diverso dal solito), ...
Non sapete cosa vuol dire? Ve le dico io: una cosa molto moderna ed alla moda! Si tratta di poter distribuire quantita' enormi di dati, anche non strutturati, su sistemi diversi. Ma vediamo il solito esempio:

for(i=0; i<3; i++)
    { db.dimmelo.save({ frase: "Ti amo!" }) };

db.dimmelo.find();

La prima cosa da notare nell'esempio e' che e' supportato il linguaggio JavaScript dall'interfaccia client. La seconda... che non viene creata la struttura di una tabella: infatti tutti i dati sono documenti, quindi non c'e' bisogno di definire nulla! Nell'esempio vengono inseriti tre documenti contenenti una frase e che vengono quindi selezionati.
Con MongoDB e' necessario utilizzare una modalita' di "basso livello" per la gestione dei dati (leggi/scrivi: find/save) e non sono presenti i costrutti di Join che debbono essere realizzati dal programmatore (come avviene nell'ISAM). In compenso si trovano meccanismi evoluti per la ricerca di dati da documenti con strutture variabili. E' quindi relativamente facile utilizzare criteri di ricerca complessi nella find(). E' infine presente una gestione automatica della replicazione e dello sharding della base dati: funzionalita' ideali per un'installazione in cloud. Insomma si e' dovuti tornare indietro su qualcosa per poter andare avanti in un'altra direzione.

Tutto qui? No: NoSQL, Big Data, Cloud Computing, teorema di CAP, ... Riferimenti: SQL, JavaScript, CouchDB, Stitch, JSON, ...

Ditelo con... CouchDB

CouchDB e' un database NoSQL. La memorizzazione e presentazione dei dati sono liberamente strutturate come documenti (in formato JSON) e non sotto forma di tabelle come avviene nelle basi dati relazionali (gia' sentito?). La caratteristica piu' notevole di CouchDB e' quella di fornire un interfaccia HTTP RESTful (REST: Representational State Transfer) a tutti i dati.
Non sapete cosa vuol dire? Vuol dire che il motore di CouchDB risponde su una porta web e che per tutte le operazioni sui dati basta utilizzare il corretto URL con un browser (o con un programma). Ma vediamo il solito esempio:

curl -X PUT http://127.0.0.1:5984/messaggi/dimmelo3 \
 -d '{"messaggio": "Ti amo!\n Ti amo!\n Ti amo!"}'

curl -X GET http://127.0.0.1:5984/messaggi/dimmelo3

Nell'esempio e' utilizzato curl: si tratta di un browser da linea di comando. Nell'esempio viene inserito un documento contenente la frase e quindi viene selezionato.
Con CouchDB e' necessario utilizzare una modalita' di "basso livello" per la gestione dei dati (CRUD: Create Read Update Delete) che vengono implementate con i comandi PUT GET DELETE dell'HTTP. Ne manca uno? L'Update si effettua con la PUT passando il rev-number, il numero della revisione del documento!
Per effettuare ricerche complesse con CouchDB si utilizzano le viste che vengono implementate con il meccanismo di Map/Reduce. Infine CouchDB implementa in modo nativo una replicazione peer-peer molto potente.

Tutto qui? No: NoSQL, Big Data, Cloud Computing, teorema di CAP, ... Riferimenti: SQL, MongoDB, JSON, Introduzione a CouchDB, ...

Ditelo con... Neo4j / Cypher

Neo4j e' un moderno database a grafo. Le informazioni in Neo4j sono costituite da Nodi, descritti da una serie di Proprieta' e posti in Relazione tra loro. In pratica si disegnano esplicitamente le relazioni tra i vari oggetti rendendo esplicito e chiaramente rappresentato ogni collegamento.
Per gestire i dati ed interrogarli si utilizza il linguaggio Cypher che ha una sintassi che ricorda quella dell'SQL (anche per il livello): l'istruzione MATCH e' analoga alla SELECT ed ha una clausola WHERE.

Neo4j ha una semplice console utilizzabile da browser (porta 7474), fornisce driver per i principali linguaggi e puo' essere utilizzato in modalita' embedded.

CREATE (p:Persona { nome: "Meo", nazione: "Italia" });
CREATE (m1:Messaggio { testo: "Ti amo!" }),
       (m2:Messaggio { testo: "Ti amo!" }),
       (m3:Messaggio { testo: "Ti amo!" }),
       (p)-[:SAYS]->(m1),
       (p)-[:SAYS]->(m2),
       (p)-[:SAYS]->(m3);

MATCH (n) RETURN n;

Ecco il risultato:

Tutto qui? No: NoSQL, ... Riferimenti: SQL, ...

Ditelo con... Kettle (ETL di Pentaho)

Pentaho e' la piu' diffusa piattaforma Open Source di Business Intelligence. Detto in altre parole, e' l'ambiente gratuito piu' utilizzato per analizzare i dati. I componenti di Pentaho sono molteplici ma per questo esempio riguarda solo alla parte di ETL (Extraction, Transformation and Loading) che e' rappresentata dal prodotto Kettle [NdA ora si chiama PDI: Pentaho Data Integration]. Kettle permette di estrarre dati da una base dati, modificarli e quindi caricarli su una seconda base dati. Gli ETL sono uno degli strumenti piu' importanti per realizzare un Data Warehouse.
La programmazione di uno script di ETL di Kettle avviene tipicamente con Spoon che offre una semplice e potente interfaccia grafica. Ecco come appare il nostro script:

I passi sono tre. Nel primo passo e' definita una stringa: "Ti amo!" come campo Field1. Il secondo passo legge la stringa e la moltiplica per tre con un semplice script:

//Dimmelo (JavaScript)
var msg='';
var i=0;

for (i=0; i<3; i++) msg=msg+Field1+'\n';

Il terzo passo definisce il nome del file di output, se questo deve essere sovrascritto, ...

Per eseguire la trasformazione e' possibile premere il bottone "Esegui" in Spoon. Lo script viene salvato in formato XML (con il suffisso .ktl), compilato ed eseguito. E' anche possibile lanciare i file .ktl da linea di comando con Pan oppure eseguirli in remoto oppure schedularli oppure ... ma diventa troppo lungo da raccontare!

La maggioranza delle trasformazioni Kettle possono essere realizzate senza alcuna programmazione ma soltanto scegliendo tra le molte opzioni possibili dei vari oggetti. Ecco come si puo' semplificare lo script indicando nello step di Input un valore (la stringa "Ti amo!") ed il numero di record (3) ed in quello di output il corretto formato:

Tutto qui? Si, per il momento ... Riferimenti: SQL, JavaScript, ...

Ditelo con... Curses

Curses e' un insieme di librerie che consentono la programmazione grafica con terminali a carattere. Le librerie sono indipendenti dal tipo di teminale, dai caratteri grafici utilizzati, ... e possono quindi essere utilizzate per ogni dispositivo.

Le librerie sono in linguaggio C e disponibili, soprattutto, per il sistema operativo Unix. La maggior parte degli ambienti grafici a carattere su Unix e' realizzata con Curses (eg. vi).
Naturalmente ora, con ambienti grafici a pixel (eg. X Windows, MS-Windows, Java AWT e Swing, ...) la grafica a carattere e' passata un po' di moda, ma noi vecchi siamo nostalgici!

/* Dimmelo in Curses
   v. 0.1 (14 02 1999) by mail@meo.bogliolo.name
*/

#define ROWS 24
#define COLS 80

main() {
int i;

initscr();

for(i=0; i<3; i++) {
    move(rand()%ROWS, rand()%COLS);
    addstr("Ti amo!");
    refresh();
    sleep(1);
    }

endwin();
}

Per compilare il file dimmelo.c dell'esempio basta lanciare il comando cc dimmelo.c -o dimmelo -lcurses.

Tutto qui? No: C, Matrix, ...

Ditelo con... X-Windows

Finalmente cambiamo argomento: il mondo X (non temete non si tratta di X-files)!
L'architettura e' semplice, insomma... abbastanza! Abbiamo un server grafico ed alcune applicazioni client. Tra loro si parlano con un protocollo (basato ovviamente sul TCP-IP) chiamato fantasiosamente X-Protocol. L'X-Server (si chiama proprio cosi') risiede su una workstation grafica e gestisce il video, il mouse, la tastiera, le finestrelle, i font, ... Gli X-Client sono applicazioni che girano su un sistema (spesso un sistema Unix) ed inviano le loro richieste grafiche all'X-Server. Tra le diverse applicazioni che e' possibile attivare una risulta sicuramente comoda: il window manager (quello che gestisce le icone, lo spostamento delle finestre sul video, ...). La gestione di tale aspetto non e' infatti stata implementata in modo rigido sull'X-Server ma e' gestita completamente da un programma. E' quindi possibile utilizzare look&feel differenti ospitando tutte le applicazioni senza modifiche.

La programmazione e' object oriented ed event driven. Consiste principalmente nel richiamo delle corrette funzioni grafiche contenute nella libreria Xlib. Ma preparatevi a scrivere tanto codice e, soprattutto, nomi di funzioni lunghissimi!
Tanto per fare un esempio la XCreate SimpleWindow() richiede 9 parametri. Meno male che e' simple!

Per sviluppare un'applicazione che utilizzi Xlib e' sufficiente creare un programma in C che richiami le corrette librerie grafiche...

/*
 * iLoveYouX.c
 *
 */

#include <X11/Xlib.h> 
#include <X11/Xutil.h> 
#include <X11/Xos.h> 
#include <X11/Xatom.h> 

#include 

Display *display;
int screen_num;

void main(argc, argv)
int argc;
char **argv;
{
        Window win;
        unsigned int width = 300, height = 300;
        int x =0, y =0;                 
        unsigned int border_width = 4;
        unsigned int display_width, display_height;
        char *window_name = "I Love You X Window Program";
        int count;
        XEvent report;
        GC gc;
        XFontStruct *font_info;
        char *display_name = NULL;
        unsigned long valuemask = 0; 
        XGCValues values;
        char *fontname = "9x15";

        if ( (display=XOpenDisplay(display_name)) == NULL )
        {
                (void) fprintf( stderr, "Cannot connect to X server %s\n", 
                                XDisplayName(display_name));
                exit( -1 );
        }

        screen_num = DefaultScreen(display);
        display_width = DisplayWidth(display, screen_num);
        display_height = DisplayHeight(display, screen_num);

        win = XCreateSimpleWindow(display, RootWindow(display,screen_num), 
                        x, y, width, height, border_width, BlackPixel(display,
                        screen_num), WhitePixel(display,screen_num));

        XSelectInput(display, win, ExposureMask | KeyPressMask | 
                        ButtonPressMask | StructureNotifyMask);

        if ((*font_info = XLoadQueryFont(display,fontname)) == NULL)
        {
                (void) fprintf( stderr, "Cannot open 9x15 font\n");
                exit( -1 );
        }

        gc = XCreateGC(display, win, valuemask, &values);

        XSetFont(display, gc, font_info->fid);

        XMapWindow(display, win);

        while (1)  {
                XNextEvent(display, &report);
                switch  (report.type) {
                case Expose:
                        if (report.xexpose.count != 0)
                                break;

                        for (i=0;i<3;i++)
                           XDrawString(display, win, gc, (i+1)*10, (i+2)*10,
                                "I love You!", strlen("I love You!");
                        break;
                case ConfigureNotify:
                        width = report.xconfigure.width;
                        height = report.xconfigure.height;
                        break;
                case ButtonPress:
                case KeyPress:
                        XUnloadFont(display, font_info->fid);
                        XFreeGC(display, gc);
                        XCloseDisplay(display);
                        exit(1);
                default:
                        break;
                } 
        } 
}

Semplice vero?
Insomma... In pratica bisogna inizializzare tutte le strutture utilizzate dal SW grafico e quindi entrare in un loop per gestire gli eventi.

Per compilare ed eseguire e' molto semplice: si tratta di un banale programma in linguaggio C (basta solo ricordare le librerie e, eventualmente, i path di include):

cc -o dimmelo dimmelo.c -lX11

Tutto qui? No: linguaggio C, ... Riferimenti:

Ditelo con... motif

Scrivere tutto con le Xlib era un poco complicato ed allora sono state introdotte funzioni di livelli differenti.

Un'applicazione X puo' essere realizzata lavorando con diversi livelli di librerie. In tutti i casi la programmazione e' sempre object oriented ed event driven. Il primo livello, che abbiamo visto prima, e' quello delle funzioni grafiche di base ed e' chiamato Xlib. Il livello superiore si basa sul concetto di widget. Si tratta di oggetti grafici "funzionanti" e con un insieme di caratteristiche di base che e' possibile personalizzare: l'X toolkit Intrinsics. Un livello ulteriore utilizza un'ampio numero di widget evoluti: i widget che realizzano l'interfaccia grafica Motif.

Per sviluppare un'applicazione che utilizzi i widget motif e' sufficiente creare un programma in C che richiami le corrette librerie grafiche...

#include <Xm/Xm.h> 
#include <Xm/Label.h> 
 
XtAppContext context;
XmStringCharSet char_set=XmSTRING_DEFAULT_CHARSET;
 
Widget toplevel, label[3];
 
main(argc,argv)
  int argc; 
  char *argv[];
{
  Arg al[10];
  int i;
 
  /* create the toplevel shell */
  toplevel = XtAppInitialize(&context,"",NULL,0, &argc,argv,NULL,NULL,0);
 
  /* create label widgets */
  i=0;
  for (i=0; i++; i<3)
  {
     XtSetArg(al[i],XmNlabelString, XmStringCreateLtoR("Ti amo!", char_set));
     label[i++]=XmCreateLabel(toplevel,"label",al,i);
     XtManageChild(label[i-1]);
  }
 
  XtRealizeWidget(toplevel);
  XtAppMainLoop(context);
}

Semplice vero?
Insomma... Certo gli strati non aiutano molto. Infatti per essere precisi la programmazione Motif non permette di nascondere le parti sottostanti di Xlib ed Xt (di cui solo in questo esempio servono ben 5 funzioni contro un'unica funzione motif).

Per compilare ed eseguire e' molto semplice: si tratta di un banale programma in linguaggio C (basta solo ricordare le librerie e, eventualmente, i path di include):

cc -o dimmelo dimmelo.c -lXm -lXt -lX11

Tutto qui? No: linguaggio C, ... Riferimenti:

Ditelo con... Tkinter

Tkinter e' l'interfaccia Python a Tk.

Tk e' un ambiente grafico completo (eg. widget, ...) spesso associato al linguaggio di scripting Tcl. Il Python offre un'interfaccia nativa a Tk: Tkinter.

from Tkinter import *

def dimmelo():
    for i in range(3):
        print "Ti amo!"
        
root = Tk()

root.bottone = Button()
root.bottone["text"]="Dimmelo"
root.bottone["command"]=dimmelo
root.bottone.pack()

root.mainloop()

Nell'esempio viene creata un'applicazione grafica contenente un bottone con il testo "Dimmelo" che, quando viene premuto, visualizza il nostro simpatico messaggio.
Facile vero?

Tutto qui? No: Python, Tk, GTK, ...

Ditelo con... GTK

GTK e' un toolkit per la realizzazione di interfacce grafiche. E' stato disegnato fin dall'inizio per supportare linguaggi di programmazione differenti ed e' quindi utilizzabile sia in C (che resta il mio linguaggio preferito ma debbo ammettere sia un po' ostico per alcuni e comunque a basso livello) che in altri semplici e diffusi linguaggi quali il Python o il Perl. Tra i programmi piu' noti realizzati in GTK vi sono lo Gnome (un'interfaccia grafica per Linux) ed il GIMP (un editor per le immagini).
GTK offre un insieme di widget molto completo ed e' quindi adatto sia a semplici singole applicazioni che alla realizzazione di ambienti grafici completi.

GTK e' costituito da tre librerie di base:

• Glib: libreria grafica di basso livello
• Pango: libreria per il layout e la gestione del testo
• ATK: libreria di interfaccia per tool esterni

Ma tutto questo, per chi programma semplici interfacce, non ha molta importanza... basta sapere che per creare un bottone con la scritta "pippo" basta richiamare gtk.Button("pippo")!

""" Programma di esempio GTK+ in Python """
import gtk

def dimmi(*args):
    for i in range(3):
        print "Ti amo!"
    window.destroy()

def destroy(*args):
    window.hide()
    gtk.main_quit()

window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("destroy", destroy)
window.set_border_width(30)
button = gtk.Button("Dimmelo!")
button.connect("clicked", dimmi)
window.add(button)
button.show()
window.show_all()
gtk.main()

# Programma di esempio GTK in Perl
use Glib qw/TRUE FALSE/;
use Gtk2 '-init';

$window = Gtk2::Window->new('toplevel');
$window->set_title("Dimmelo!");
$window->set_border_width(30);

my $button = Gtk2::Button->new('Dimmelo');
$button->signal_connect('clicked' =>
    sub { 
        for ($i=0; $i<3; $i++) {
            printf "Ti amo!\n";
        } ;
        Gtk2->main_quit; });

$window->add($button);
$button->show;
$window->show_all();

Gtk2->main;
0;

Certo piu' semplice della programmazione su X!
Nell'esempio, visto che si tratta di un programma Python bastera' eseguire python dimmelo.py.

Tutto qui? No: Perl, Python, ... Riferimenti:

Ditelo con... i socket (client)

Il TCP e' oramai il protocollo di rete piu' diffuso ed offre un'interfaccia di programmazione per costruire programmi di rete chiamata socket library.

Con tale interfaccia sono costruiti la maggioranza dei servizi e delle applicazioni di rete. L'architettura prevede programmi Client che richiedono servizi e programmi Server che li forniscono.
Le opzioni ed i protocolli disponibili sono innumerevoli (in effetti e' sbagliato parlare di Client TCP, si tratta solo di un caso particolare) ma l'esempio che segue, realizzato con il potente linguaggio Python, e' la base di moltissimi programmi di rete.

# Client TCP in Python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("meotec.da.ru",80))
s.send("GET /\n")
print(s.recv(1000))

Nell'esempio viene presentato un esempio semplicissimo di un programma client che invia una stringa di caratteri e che riceve una risposta.
Avete capito di che si tratta? Un browser (Internet Explorer, Mozzilla, Netscape, ...) fa esattamente quello che e' presentato nell'esempio!
Poca differenza ci sarebbe comunque con un client FTP, un gestore di posta, il SIP (simpatico protocollo VoIP), ... ma in questo caso la richiesta non sarebbe stata GET e bisognava cambiare la porta (80 e' il default per i servizi web)!

Tutto qui? No: socket (Server), HTML, Dialoghi Platonici, ...

Ditelo con... i socket (Server)

La parte Server e' un poco piu' complicata... ma riusciremo comunque nel nostro romantico scopo!

Il server deve creare un socket, mettersi in ascolto su una porta e rispondere a tutte le richieste di servizio.
Anche in questo caso le opzioni sono innumerevoli: possono essere utilizzati piu' thread per rispondere a richieste in parallelo, possono essere utilizzate richieste non sospensive, si puo' rimanere in ascolto su piu' porte e servizi, ...

# Server TCP in Python
import socket
sSer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sSer.bind((socket.gethostname(), 80))
sSer.listen(5)
while 1:
    (sCli, addr) = sSer.accept()
    sCli.recv(1000)
    sCli.send('')
    for i in range(3):
        sCli.send('Ti amo!')
    sCli.send('')
    sCli.close()

Nell'esempio viene presentato un esempio semplicissimo. Il server riceve una richiesta, invia la risposta e chiude la connessione.
Avete capito di che si tratta? Un web server (eg. Apache, IIS, ...) fa esattamente questo!
Poca differenza, mutatis mutandis, ci sarebbe comunque con altri servizi (eg. FTP, POP-3, ...)

Tutto chiaro? Se avete capito questi ultimi due esempi avete capito come funziona il 95% del mondo informatico di oggi!

Tutto qui? No: socket Client, socket Client (PL/SQL), HTML, Dialoghi Platonici, ...

Ditelo con... i socket (client) PL/SQL

Il PL/SQL e' il linguaggio procedurale dell'RDBMS Oracle... quindi piu' adatto a creare stored procedures e trigger ma come molti altri linguaggi ed ambienti fornisce un'interfaccia socket. In effetti sarebbe stato banale presentare un esempio in C!

DECLARE
  c  utl_tcp.connection; 
  ret_val pls_integer; 
BEGIN
  c := utl_tcp.open_connection(remote_host => 'meotec.da.ru',
                               remote_port =>  80,
                               charset     => 'US7ASCII');  
  ret_val := utl_tcp.write_line(c, 'GET / HTTP/1.0');    
  ret_val := utl_tcp.write_line(c);
  BEGIN
    LOOP
      dbms_output.put_line(utl_tcp.get_line(c, TRUE));  
    END LOOP;
  EXCEPTION
    WHEN utl_tcp.end_of_input THEN
      NULL; -- end of input
  END;
  utl_tcp.close_connection(c);
END;

Nell'esempio viene presentato un semplice client che utilizza la socket interface. Quando si lavora in rete non contano i linguaggi di programmazione, gli ambienti, ... l'unica cosa che conta e' il protocollo utilizzato ovvero le domande e le risposte che vengono scambiate.
E' spesso piu' facile far parlare due linguaggi in rete che linkarli assieme sulla stessa macchina... a volte e' cosi' anche con le persone!

Tutto qui? No: PL/SQL, ...

Ditelo con... l'HTML

Il linguaggio HTML non e' un linguaggio di programmazione. Si tratta infatti di un semplice linguaggio di formattazione dei testi. Ho voluto riportarlo ugualmente poiche' con Internet la sua diffusione e' fortissima.

Scrivere in HTML e' molto semplice. Infatti si scrive esattamente quello che si vuole leggere! Il testo viene "arricchito" con dei TAG che indicano che una determinata parte ha un trattamento particolare. Viene sempre posto un tag all'inizio ed uno alla fine del testo interessato.

Per rendere questo documento visibile su Internet con il suo romantico contenuto e' sufficiente scaricarlo su una directory di un Web Server e sara' cosi' visibile su tutto Internet (che e' assai piu' grande del mondo conosciuto). Il nome del file dovra' avere il suffisso corretto: ad esempio Dimmelo.html.

Come funziona? Semplice!
Il file in HTML viene ospitato sul Web Server. Quando un browser, indicando il corretto URL (l'indirizzo in pratica) richiede il file, il web server lo invia attraverso la rete con il protocollo HTTP. Ricevuto il file il browser si occupa della corretta visualizzazione.

Tutto qui? No: HTML5, ... Riferimenti: ...

Ditelo con... XML

Il linguaggio XML e' nato come evoluzione dell'HTML. L'HTML infatti aveva avuto un enorme successo ma possedeva anche alcuni limiti che il consorzio W3C ha voluto superare definendo un nuovo linguaggio: l'XML.

Dal punto di vista tecnico l'XML e' una particolare implementazione dell'SGML, ma dal punto di vista pratico e' piu' semplice spiegarlo per le sue differenze con l'HTML.
Sintatticamente si tratta di poche cose. Anche l'XML utilizza TAG delimitati con < e >. I tag sono sempre in minuscolo e le variabili vanno sempre racchiuse tra doppi apici. I tag debbono sempre essere chiusi e, si tratta di un tag singolo la chiusura e' \> Non sono concessi errori sintattici... Le differenze sono quindi poche!
Ma la novita' fondamentale e' che l'XML consente di estendere il linguaggio a piacere creando nuovi TAG. Con il DTD (Document Type Definitions) si possono creare nuove tipologie di documenti estendendo il linguaggio a piacere. Pubblicando un DTD si rende tale rappresentazione disponibile a chiunque ed e' cosi' possibile lo scambio di informazioni strutturate.

Aggiornamento!
Oltre ai DTD si stanno diffondendo gli XML Schema Definition o XSD che risultano molto piu' flessibili nella definizione dei documenti da parte di un'applicazione.

La definizione precisa del linguaggio lo rende molto facilmente trattabile da parte di programmi e la sua estendibilita' lo rende adatto a rappresentare dati.

<?xml version="1.0" encoding="ISO-8859-1"?>
< 
     Documento XML di esempio
     Autore: meo
 -->
<DOCTYPE messaggio [
<ELEMENT messaggio (frase*)>
<ELEMENT frase (#PCDATA)>
]>
        
<messaggio>
  <frase>Ti amo!</frase>
  <frase>Ti amo!</frase>
  <frase>Ti amo!</frase>
</messaggio>

Creato un file dimmelo.xml con il contenuto XML dell'esempio si puo' pubblicare come un qualsiasi altro file .HTML.
Il file puo' essere letto da un browser ma anche, in modo semplice, da un'applicazione come avviene nelle architetture SOA.

Tutto qui? No: html, xhtml, SOAP (Cache'), SOAP (PHP), ...

Ditelo con... SGML

L'HTML e' un subset di un piu' ampio standard ISO chiamato SGML (Standard Generalized Markup Language). L'utilizzo dell'SGML e' piu' ampio poiche' consente di definire i contenuti non la forma di visualizzazione. Quest'ultima puo' essere scelta di volta in volta e puo' essere adatta alla stampa di un libro, alla presentazione su un browser, alla realizzazione di un CD-ROM, ...

SGML consente la definizione di DTD (document type definitions) contenenti TAG e l'HTML e' uno specifico DTD. Una particolarita'? Tra i TAG ve ne e' uno che consente di definire il collegamento ad un altro documento (HyperLink). Una cosa semplice ma che ha fatto crescere il Web ed Intenet in modo esponenziale e senza il quale ne lo standard ISO SGML ne questo documento esisterebbero!

Tutto qui? No: HTML, XML, XHTML, ...

Ditelo con... XHTML

Il linguaggio XHTML e' l'evoluzione dell'HTML. Si tratta di un documento XML e' quindi presente l'indicazione del DTD (Document Type Definitions) ed utilizza i TAG con il formato tipico dell'XML.

L'XHTML ha molte estensioni rispetto all'HTML pero'... e' chiaramente piu' complesso!

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head><meta http-equiv="content-type" content="text/html; charset=utf-8" /><title />
    <meta name="generator" content="StarOffice/OpenOffice.org XSLT (http://xml.openoffice.org/sx2ml)" />
    <meta name="author" content="meo bogliolo" /><meta name="created" content="2006-02-17T17:17:17" /><base href="." />
        <style type="text/css">
        @page { size: 20.999cm 29.699cm; margin-top: 2cm; margin-bottom: 2cm; margin-left: 2cm; margin-right: 2cm }
        table { border-collapse:collapse; border-spacing:0; empty-cells:show }
        td, th { vertical-align:top; }
        h1, h2, h3, h4, h5, h6 { clear:both }
        ol, ul { padding:0; }
        * { margin:0; }
        *.Caption { font-family:'Times New Roman'; font-size:12pt; margin-top:0.212cm; margin-bottom:0.212cm; font-style:italic; }
        *.Heading { font-family:Arial; font-size:14pt; margin-top:0.423cm; margin-bottom:0.212cm; }
        *.Index { font-family:'Times New Roman'; font-size:12pt; }
        *.List { font-family:'Times New Roman'; font-size:12pt; margin-top:0cm; margin-bottom:0.212cm; }
        *.Standard { font-family:'Times New Roman'; font-size:12pt; }
        *.Textbody { font-family:'Times New Roman'; font-size:12pt; margin-top:0cm; margin-bottom:0.212cm; }
        </style>
  </head>
  <body dir="ltr">
    <p class="Standard">Ti amo! </p>
    <p class="Standard">Ti amo! </p>
    <p class="Standard">Ti amo! </p>
  </body>
</html>

Pubblicare un documento XHTML e' analogo a pubblicare un HTML. Le uniche avvertenze, per avere una rappresentazione perfetta del file, sono che e' necessario utilizzare un browser recente ed il DTD deve essere accessibile!

Tutto qui? No: HTML, XML, ...

Ditelo con... l'HTML5

L'HTML5 e' l'evoluzione del linguaggio HTML.
La diffusione di Internet, del Word Wide Web e del linguaggio HTML e' stata enorme. Ma l'evoluzione prevista dell'HTML verso forme piu' strutturate come l'XML ed l'XHTML non ha trovato la convergenza sperata dal W3C (il consorzio che definisce le linee di guida del Word Wide Web). Sono nate estensioni e variazioni non standard dell'HTML, alcune di notevole impatto ed importanza come Flash e VB Script. Altre implementate solo da alcuni browser con TAG ed attributi aggiuntivi...

Con una scelta pragmatica e coraggiosa il W3C ha deciso di definire un nuovo standard chiamato HTML5 che al tempo stesso elimina delle parti e ne introduce di nuove.
L'HTML5 e' ricco di nuove funzionalita' per la grafica, la multimedialita', i dispositivi mobile, ... Ma l'altra scelta importante del W3C e' stata quella di semplificare il linguaggio escludendo quanto non era stato implementato dalla maggioranza dei browser.

<!DOCTYPE html>
<html>

<head>
<meta charset="UTF-8" />
<title>Dimmelo!</title>
</head>

<body>
Ti amo!
<br \>Ti amo!
<br \>Ti amo!
</body>

</html>

Dal punto di vista di pubblicazione non vi sono differenze rispetto all'HTML. Anche se l'HTML5 non e' ancora ufficialmente uno standard [NdE Q2 2012] la maggioranza dei browser ne implementano gia' le principali funzioni.

Tutto qui? No: HTML, ... Riferimenti: Esempi HTML5

Ditelo con... CGI

Il CGI (Common Gateway Interface) non e' affatto un linguaggio. E' uno standard su come si debbono comportare le applicazioni per poter essere ospitate su un Web Server. Con un programma realizzato seguendo lo standard CGI e' possibile rendere "attive" le pagine altrimenti statiche realizzate con l'HTML. Un programma CGI puo' essere realizzato con diversi linguaggi. Nel seguito utilizzeremo la Bourne shell semplicemente perche' e' semplice!

Per poter essere un'applicazione pubblicabile come CGI un programma deve scrivere in output un paio di semplici righe e quindi una pagina HTML corretta. Non vi sono altri particolari requisiti (ovviamente per ottenere i dati da inserire nella pagina HTML il programma puo' accedere a basi dati, fare elaborazioni, ...).

#!/bin/sh    
# Esempio di programma CGI in Bourne shell

echo "Content-type: text/html"
echo   

echo "<html>"
echo "<body>"
i=0
while [ $i -lt 3 ]
do
        echo "<br>Ti Amo!"
        i=`expr $i + 1`
done    
echo "</body>"
echo "</html>"

La prima riga non e' un commento ma serve ad indicare al sistema (unix) che si tratta di un programma shell; allo stesso modo le due echo sucessive sono necessarie per dichiarare il tipo di documento trasmesso al browser. E' importante notare che l'applicazione CGI viene eseguita sul web server. Verso il browser arrivano pagine HTML "normali". Con le applicazioni CGI e' anche possibile "leggere" i dati inseriti dall'utente, ma questo e' un altro discorso...

Come funziona? Semplice!
Dal punto di vista del browser non cambia nulla rispetto alla visualizzazione di un normale file HTML. Il Web server si accorge che l'URL richiesto non corrisponde ad un file di testo ma ad un programma da eseguire (perche' appartiene ad un virtual directory... ma non complichiamoci la vita: lo capisce e basta!). Quindi esegue il programma e tutto l'output che genera viene rispedito al browser come un normale file HTML.

Tutto qui? No: ... Riferimenti: ...

Ditelo con... il LAMP

LAMP e' un acronimo che indica un insieme di linguaggi o, forse meglio, un'architettura (LAMP: Linux Apache MySQL Perl/PHP/Python).

Con LAMP si intende una piattaforma completa che consente di sviluppare applicazioni robuste ed efficenti utilizzando solo software libero.
Linux e' il sistema operativo che ospita file system, ambienti ed applicazioni. Apache il web server che, con i suoi moduli, supporta diversi linguaggi di scripting. MySQL e' l'RDBMS che mantiene i dati sul database. Perl / PHP / Python sono tre potenti linguaggi per la scrittura di applicazioni su web.

<?php
# Esempio in LAMP (Linux Apache MySQL PHP)

$cnn = mysql_connect('localhost', 'root', '');
$sql = "SELECT testo FROM test.dimmelo";
$result = mysql_query($sql);
while ($record = mysql_fetch_array($result)) {
   echo $record['testo'] . "<br>";
   }
?>

Come in tutti gli altri esempi di codice il programma e' molto semplice. Ma quanto e' completo questo programma? Se si dovesse avere una completa gestione degli errori e dell'interfaccia quanto sarebbe piu' complicato? Non molto piu' complesso, come si puo' vedere nell'esempio che segue:

<?php
# Esempio "completo" in LAMP (MySQL+PHP)

if ($cnn = mysql_connect('localhost', 'root', '')) {
    if (mysql_select_db('test', $cnn)) {
        $sql = "SELECT testo FROM dimmelo";
        if ($result = mysql_query($sql)) {
            $num_rows = mysql_num_rows($result);
            if ($num_rows > 0) {
                while ($record = mysql_fetch_array($result)) {
                    echo $record['testo'] . "<br>";
                }
            }
        }
        else {
            echo "Error: " . mysql_error();
        }
    }
    else {
    }
}
else {
    echo "Error connecting to server: " . mysql_error();
}
?>

L'esempio e' un poco piu' lungo di altri poiche' contiene la gestione completa degli errori... In ogni caso il tratto di codice necessario per collegarsi al DB e presentare i dati come pagina HTML su web e' effettivamente semplice. Realizzare applicazioni con il LAMP e' economico ed efficiente.
Anche il publishing e' banale: basta porre il file in una directory del web server come se fosse una semplice pagina HTML.

Tutto qui? No: SQL, PHP, Perl, Python, HTML, ...

Ditelo con... LAPO

LAPO e' un acronimo che mi sono inventato io!
L'architettura LAMP (Linux Apache Mysql Perl/Php/Python) conosce diverse varianti come WAMP (dove si utilizza il sistema operativo Windows anziche' Linux), LAPP (dove si utilizza il database PostgreSQL anziche' MySQL), ...

Come chiamare un'architettura che consente di accedere all'RDBMS Oracle (Linux Apache Oracle Perl/Php) se non LAPO?
Vediamo quindi un semplice esempio che permette di accedere ad Oracle con il PHP:

<?php

$conn = oci_connect("scott", "tiger", "localhost:1569/XE");
if (!$conn) {
    $e = oci_error();
    trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
}
$stid = oci_parse($conn, 'SELECT * FROM dimmelo');
oci_execute($stid);
echo "<table border='1'>\n";
while ($row = oci_fetch_array($stid, OCI_ASSOC+OCI_RETURN_NULLS)) {
    echo "<tr>\n";
    foreach ($row as $item) {
        echo "    <td>" . ($item !== null ? htmlentities($item, ENT_QUOTES) : " ") . "<td>\n";
    }
    echo "<tr>\n";
}
echo "<table>\n";

?>

Il publishing e' banale: come con il LAMP basta porre il file in una directory del web server come con una semplice pagina HTML.
Un poco meno semplice e' la configurazione. Trattandosi di ambienti solo in parte Open Source, trovare tutti i componenti nelle versioni corrette e con i link alle librerie giuste non e' immediato. Pero' prima o si riesce: bastano l'estensione php-oci ed un client Oracle (eg. Oracle Instant Client Basic+Devel) con versioni/architettura allineate tra loro, con il PHP ed il server Apache.

Tutto qui? No: SQL, PHP, Perl, HTML, ...

Come il vero e sicuramente romantico Lapo possa dire "Ti amo!"... beh al momento non ci e' dato di saperlo!

Ditelo con... LAPP

L'abbiamo nominato ed eccolo anche lui! Rispetto all'architettura LAMP utilizziamo il database Open PostgreSQL (Linux Apache PostgreSQL Perl/Php/Python).
Vediamo quindi il solito esempio che permette di accedere a PostgreSQL con il PHP:

<?php

# Esempio in LAPP (PostgreSQL+PHP)
$cnn = pg_connect("host=pg.xenialab.it port=5432 dbname=postgres user=postgres password=postgres");
$sql = "SELECT testo FROM dimmelo";
$result = pg_query($sql);
while ($record = pg_fetch_array($result)) {
   echo $record['testo'] . "<br>\n";
   }
}

?>

Il publishing e' banale: basta porre il file .php in una directory del web server come con una semplice pagina HTML.
Anche la configurazione e' semplice, basta installare i moduli aggiuntivi php-pdo e php-pgsql su una normale installazione Apache e PHP.

Tutto qui? No: SQL, PHP, Perl, HTML, ...

Ditelo con... AngularJS

AngularJS e' un framework MVC (Model View Controller) per realizzare applicazioni web. Citando il sito ufficiale: "Angular è quello che HTML avrebbe dovuto essere se fosse stato progettato per sviluppare applicazioni"

Angular definisce una struttura alle applicazioni collegando la parte algoritmica (in JavaScript) con la parte di presentazione dei dati.

Il publishing e' banale: basta porre il file in una directory del web server come se fosse una semplice pagina HTML.

Tutto qui? No: MongoDB, NodeJS, MEAN, JavaScript, HTML, ...

Ditelo con... il MEAN

MEAN e' un acronimo che indica una moderna architettura alternativa al LAMP.

Lo stack che compone MEAN e' costituito da MongoDB, ExpressJS, AngularJS, NodeJS.
A differenza del LAMP il sistema operativo non e' indicato come componente poiche' Node.js puo' essere eseguito su sistemi differenti. La parte di database e' costituita dal database NoSQL MongoDB, ExpressJS e' la componente Web ed AngularJS e' il framework MVC. Tutti i componenti sono Open Source.

Il linguaggio utilizzato e' sempre JavaScript mentre per lo scambio e la memorizzazione dei dati si utilizza il formato JSON.

Lo stack MEAN consente di creare applicazioni web molto efficienti.
Anche il publishing e' banale: basta porre il file in una directory del web server come se fosse una semplice pagina HTML.

Tutto qui? No: MongoDB, NodeJS, AngularJS, JavaScript, HTML, ...

Ditelo con... T9

Il linguaggio T9 ha una ragione molto semplice: scrivere velocemente messaggi testuali con una tastiera numerica. Per esempio scrivere un SMS con la tastiera di un cellulare.

Ogni tasto corrispondono a piu' lettere (eg 2 abc) ed una pressione ripetuta dello stesso tasto e' vengono passate in sucessione. Questo pero' vuol dire che ogni volta che si vuole la lettera C e' necessario premere il tasto 2 tre volte.
Poiche' chi utilizza smodatamente gli SMS ha molta fretta e' stato realizzato il T9 che consente di premere i tasti una sola volta. Poiche' chi utilizza smodatamente gli SMS non ne ha molta... l'intelligenza e' costretto a metterla il cellulare! Il T9 mantiene un vocabolario con le parole piu' diffuse e cerca di indovinare la parola che l'utente scrive. E' quindi sufficiente premere un solo tasto per lettera, il T9 scegliera' quella giusta. In caso di ambiguita? Basta premere * fino a che non appare la parola giusta.

84****0266****1****084****0266****1****084****0266****1****0

No comment!

Tutto qui? No: WAP, ...

Ditelo con... il WAP

WAP sta per Wireless Application Protocol ed e' una collezione di standard di recente introduzione applicabili alla telefonica cellulare. Adottando tale standard un telefono cellulare evoluto puo' mostrare (sul suo limitato display) un testo interattivo e navigabile come un testo HTML su Internet. In realta' il testo non e' in HTML ma in WML, ma e' un nome meno conosciuto e si assomigliano molto... Lo standard WAP ricorda molto da vicino gli analoghi protocolli e standard dell'ambiente Internet.
Vi sono tuttavia una serie di importanti differenze. WAP infatti tiene conto di reti con elevata latenza e scarsa banda e di display con limitate possibilita' grafiche.

Scrivere in WML e' molto semplice. Infatti si scrive esattamente quello che si vuole leggere! Il testo viene "arricchito" con dei TAG che indicano che una determinata parte ha un trattamento particolare. Viene sempre posto un tag all'inizio ed uno alla fine del testo interessato. Per tale motivo la serie di pagine (card) che compongono un deck viene scaricata in un solo passo ed il dialogo tra proxy server e terminale WAP avviene in forma compressa.

Per rendere questo documento visibile su Internet con il suo romantico contenuto e' sufficiente scaricarlo su una directory di un Web Server, disporre di un proxy server WAP e sara' cosi' visibile su tutti i cellulari (WAP) del mondo.

Come funziona? Semplice!
L'architettura e' analoga a quella di un Web Server. La differenze principali stanno nei protocolli che sono ottimizzati per la trasmissione via GSM. Percio' il proxy server Wap si occupa di convertire i messaggi tra i due protocolli...

Tutto qui? No: ... Riferimenti: ...

Ditelo con... Android SDK

Android SDK e' l'ambiente che consente di sviluppare applicazioni per cellulari Android.
Per essere precisi Android e' un sistema operativo Linux, ottimizzato per sistemi con modeste capacita' elaborative e di memoria. Android e' stato sviluppato da Google appositamente per telefoni cellulari: i famosi Smartphone. I programmi applicativi "girano" all'interno di Dalvik una JVM (Java Virtual Machine) register-based. Per lo sviluppo delle applicazioni e' utilizzato l'Android SDK, tipicamente installato come Plug-in Eclipse.
Chiarito tutto questo (e' tutto chiaro vero?), un'applicazione Android e' semplicemente un programma Java! E per realizzarlo si utilizza l'Android SDK.

package com.example.tiamo;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class TiAmo extends Activity {
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       TextView messaggio = new TextView(this);
       messaggio.setText("Ti amo!");
       setContentView(messaggio);
   }
}

Realizzato il programma va compilato ed impacchettato il tutto in un file di pacchetto .apk Ora la nostra applicazione e' pronta! Cosa ne facciamo? Possiamo provarla con l'emulatore (lentissimo), installarla sul nostro cellulare (con adb install) oppure pubblicarla sull'App Market e sperare di diventare milionari con le vendite!

Tutto qui? No! Sono molto importanti gli ambienti di sviluppo che risultano concorrenti di Android come: Xcode (per applicazioni COCOA su iPhone, iPad e iPod con iOS), QT Developer (per Nokia Symbian e Maemo), Microsoft Mobile, ... Caratteristiche HW, modelli di cellulari, sistemi operativi, App Market, architetture applicative, ... sono tutte diverse ma il mercato potenziale dei prossimi anni e' enorme e quindi le innovazioni sono continue su tutti i fronti!
Riferimenti: Java, AppInventor for Android, ...

Ditelo con... Cocoa

Il Framework Cocoa e' la base per la programmazione su MAC OS X (il sistema operativo Unix-like di Apple per i propri PC) e per iOS (il sistema operativo dei dispositivi iPhone, iPad ed iPod).

Si tratta di un framework molto completo poiche' contiene anche le funzioni di libreria oltre a tutta la parte grafica. Il linguaggio utilizzato e' l'Objective-C di cui vengono utilizzati in modo significativo le caratteristiche ad oggetti come la definizione delle classi e lo scambio di messaggi. Le classi Cocoa sono facilmente riconoscibili perche' hanno tutte il prefisso NS, da NextStep il sistema operativo su cui e' basata l'ultima generazione dei MAC OS X.
Ecco un esempio:

//
//  main.m
//  Dimmelo
//
//  Created by meo on 14/2/2013.
//  Copyright 2013 __MyCompanyName__. All rights reserved.
//

#import 

int main(int argc, char *argv[])
{
	int i;
	for (i=0; i<3; i++)
		NSLog(@"Ti amo!");
	
    return NSApplicationMain(argc,  (const char **) argv);
}

L'esempio riportato e' molto semplice: attiva un'applicazione "vuota" e scrive sul log della console il nostro importante messaggio! Ma con Cocoa si programmano principalmente interfacce grafiche.

La programmazione si effettua con l'IDE Xcode che genera tutta la struttura necessaria. Per eseguire il programma? Basta premere il bottone Run (Build and Run, per essere precisi)!
I messaggi inviati con NSLog sono visibili sulla Debugger Console, generalmente visibile su Xcode.

Tutto qui? No: Objective-C, linguaggio C, ...

Ditelo con... Zlango

Il linguaggio Zlango e' un recentissimo linguaggio ad ideogrammi ideato per la comunicazione con i cellulari o con qualsiasi altro mezzo di comunicazione che permetta lo scambio di immagini.

La struttura del linguaggio e' molto semplice, quasi banale: si tratta di circa 200 icone organizzate per categorie... In realta' l'aspetto piu' interessante e' che il linguaggio e' estensibile e crescera' a seconda dell'utilizzo degli utenti.

Nell'esempio viene riportato il nostro classico esempio. Facile vero?

Tutto qui? No: T9, ...

Ditelo con... un Applet Java

Il linguaggio Java consente di produrre particolari programmi detti Applet, che possono essere scaricati da Internet ed eseguiti all'interno dei piu' comuni "navigatori" o browser (eg. Netscape o Internet Explorer)
La differenza fondamentale tra un'applicazione Java ed un applet Java sta nel fatto che l'applet viene eseguito su un browser. La JVM del browser consente un limitato accesso alle funzioni di sistema da parte del programma java in modo da evitare "virus" o altre infestazioni da parte di programmi maliziosi.

/**
        Esempio di Applet Java
*/

import java.awt.*;

public class Dimmelo extends java.applet.Applet
{
    public void paint(Graphics g) {
        int i;

        for (i=0; i<3; )                          
            g.drawString("Ti amo!", 1, 16*++i);
    }
}

Per ospitare tale programma su web e' necessario includerlo in una pagina HTML come quella che segue:

<html>
<head>
<! Esempio con un Java Applet>
<title>Ditelo con... un applet</title>
</head>
<body>
<applet code=dimmelo.class HEIGHT=100 WIDTH=100>
</applet>Esempio Applet Java...
</body>
</html>

La compilazione e' analoga a quella di un programma Java (basta lanciare javac dimmelo.java). Per la pubblicazione sul web server dell'Applet e della pagina HTML ospite le indicazioni sono invece analoghe a quelle relative all'HTML.

Come funziona? Semplice!
O quasi... La pagina che contiene l'applet e' una pagina HTML normale per il Web Server. L'applet e' scritto in bytecode e viene semplicemente scaricato al browser. Quando il browser ha ricevuto il codice attiva una JVM (Java Virtual Machine) ed esegue il codice dell'applet. Quindi l'applet gira sul browser come in questo esempio.

Tutto qui? No: security sandbox, bytecode, architetture distribuite, servlet, classi fondamentali, RMI, ... Riferimenti: Ditelo con... Java, Developing Custom and Standard Interfaces to Oracle RDBMS in Java, Using Java Standard Interfaces to Oracle, ...

Ditelo con... un Applet Java firmato

Java e' diventato il linguaggio piu' diffuso per le applicazioni professionali su web arricchendosi di funzionalita' ed introducendo nuovi problemi di sicurezza. L'evoluzione e' stata molto forte sia sui browser che sugli ambienti di sviluppo di java (JDK).

Un applet puo' essere eseguito nella sandbox senza possibilita' di interazione oppure richiedere un accesso alle risorse del client. Per ragioni di sicurezza i browser accettano solo applet firmati, le firme hanno una data di scadenza, i timestamp debbono essere certificati, le Certification Authorities (CA) debbono essere affidabili (trusted), ... insomma e' tutto molto piu' difficile!

/**
        Esempio di Applet Java
*/

import java.awt.*;

public class Dimmelo extends java.applet.Applet
{
    public void paint(Graphics g) {
        int i;

        for (i=0; i<3; )                          
            g.drawString("Ti amo!", 1, 16*++i);
    }
}

Dal punto di vista di programmazione non e' cambiato nulla, l'applet e' sempre lo stesso. Ora pero' e' necessario impacchettarlo in un Jar file che contiene qualche ulteriore informazione nel MANIFEST.MF. Per ospitare il programma su web e' necessario includerlo in una pagina HTML come quella che segue:

<html>
<head>
<! Esempio con un Java Applet firmato>
<title>Ditelo con... un applet</title>
</head>
<body>
<applet code=dimmelo.class archive="Dimmelo.jar" HEIGHT=100 WIDTH=100>
</applet>Esempio Applet Java firmato...
</body>
</html>

Dal punto di vista della programmazione non e' cambiato nulla. L'applet si compila sempre con javac Dimmelo.java che genera il file Dimmelo.class. E' necessario creare una propria firma digitale con il comando (una sola volta): keytool -genkey -dname "cn=Meo" -validity 365 -storepass mySPass -keypass myKeyP La classe ottenuta va inclusa in un Jar file con il comando (ogni volta che si firma un applet): jarsigner -storepass mySPass -keypass myKeyP -tsa http://tsa.xeniaTSA.org/ Dimmelo.jar mykey Sarebbe inoltre opportuno aggiungere le informazioni sulle permission richieste dall'applet e sull'autore nel manifest... ma non e' il caso di addentrarsi nei particolari in questo semplice esempio. Per la pubblicazione sul web server dell'Applet e della pagina HTML ospite le indicazioni sono invece analoghe a quelle relative all'HTML.

Come funziona? Semplice!
O quasi... La pagina che contiene l'applet e' una pagina HTML normale per il Web Server. L'applet e' scritto in bytecode e viene semplicemente scaricato al browser. Il plugin del browser controlla se Java e' abilitato sul sito e quali sono le condizioni di sicurezza chiedendo eventualmente conferma all'utente. Se tutto va bene il browser attiva una JVM (Java Virtual Machine) ed esegue il codice dell'applet. Quindi l'applet gira sul browser come in questo esempio.

Tutto qui? No: ... Riferimenti: Ditelo con... Java, Ditelo con... Applet Java, ...

Ditelo con... RMI

L'RMI introduce una flessibilita' notevole nel disegno delle applicazioni distribuite con Java.
L'idea di base e' quella dell'RPC (remote procedure call) ed anche la generazione di stub, la definizione delle interfacce sono simili. Ma l'utilizzo nativo di oggetti e la portabilita' intrinseca di Java rendono la tecnica assai piu' ricca di potenzialita'. RMI (Remote Method Invocation) e' un API Java per effettuare richiami di procedure remote. L'RMI e' un'API generalizzata poiche' permette implementazioni differenti. Quella iniziale e' indicata dalla sigla JRMP mentre la piu' diffusa (che useremo nell'esempio seguente) e' RMI-IIOP che si basa su CORBA.

CORBA e' un ORB (object request broker) ovvero un software che consente il richiamo remoto di oggetti in rete e ne fornisce l'infrastruttura (serialization, naming, ...). CORBA utilizza l'IDL (Interface Description Language) per descrivere le strutture dei dati.
L'utilizzo e' piutosto semplice e richiede di sviluppare il codice di due interfacce (una per il client che richiede la funzionalita' ed una per il server che la fornisce). Le interfacce:

public interface myServer extends Remote
{
  void receiveRequest(myClient client, String message) throws RemoteException;
}

public interface myClient extends Remote
{
  void receiveReply(String message) throws RemoteException;
}

L'implementazione e' quindi costituita da una parte server:

public class MyServerImpl implements myServer
{
   void receiveRequest(myClient client, String message) throws RemoteException
   {
     String reply = "";
     Int i;
     
     for (i=0;i<3;)
        reply = reply+"Ti amo!\n"

     client.receive(reply);
   }
}

E da una parte client:

public class MyClientImpl implements myClient
{
   MyServer server;
   public MyClientImpl(String Server_IOR, ORB orb)
     throws Exception
   {
     server = (MyServer) PortableRemoteObject.narrow(
                 orb.string_to_object(Server_IOR), MyServer.class);
   }
   void receiveReply(String message) throws RemoteException
   {
     System.out.println(message);
   }
   public void talk(String conversation)
   {
      server.receiveRequest(this, conversation);
   }
}
the_client.talk("Dimmelo!");

Basta utilizzare il package dell'implementazione RMI-IIOP (javax.rmi.CORBA) e tutto funziona correttamente.
Grazie alla possibilita' dell'RMI di richiamare funzioni remote questa tecnica viene spesso utilizzata negli Applet. In questo modo si puo' realizzare un'architettura in cui l'applet si occupa della presentazione grafica e la logica di business e' implementata su servizi remoti ospitati sul server.

Tutto qui? No: ci sarebbe qualche dettaglio in piu' sull'rmic, l'rmiregistry, le socket factory, l'utilizzo con firewall, la sandbox, ... ma ve li risparmio. Piuttosto vedete: java, EJB, socket interface, ...

Ditelo con... un Servlet

Il linguaggio Java consente anche di produrre particolari programmi detti Servlet, che vengono eseguiti sul sistema che ospita il web server ed il cui output e' una pagina HTML visibile con tutti i "navigatori" o browser (eg. Netscape o Internet Explorer)
La differenza fondamentale tra un Applet Java ed un Servlet e' che che l'Applet viene eseguito su un browser mentre il Servlet viene eseguito sul Web Server/Application Server.

Dal punto di vista di programmazione si tratta di realizzare un programma Java che estenda la classe HttpServlet. Tipicamente vengono sviluppati uno o piu' metodi (eg. doGet, doPost, in modo da effettuare l'override dei metodi forniti dalla classe).

/*
 * @(#)ILoveYouServlet.java   1.00 03/02/14
 *
 * Copyright (c) 2001-2003 Meo
 *
 * CopyrightVersion 1.0
 */

import java.io.*;

import javax.servlet.*;
import javax.servlet.http.*;

/**
 * I Love You. This servlet simply prints I love You!
 *
 * Since I am a very boring man it prints "I love You" three times...
 */

public
class ILoveYou extends HttpServlet {

    public void doGet (HttpServletRequest req, HttpServletResponse res)
        throws ServletException, IOException
    {
        int i;

        res.setContentType("text/html");

        ServletOutputStream out = res.getOutputStream();
        out.println("<html>");
        out.println("<head><title>I Love You</title></head>");
        out.println("<body>");
        for (i=0; i<3; )                          
                out.println("I love You!");
        out.println("</body></html>");
    }

    public String getServletInfo() {
        return "Create a page that says <i>I love You!<i> three times";
    }
}

La compilazione e' analoga a quella di un programma Java.
Per la compilazione e' sufficiente seguire le indicazioni relative ai programmi Java. Occhio ai package... (facilmente dovranno essere aggiunti nel CLASSPATH i riferimenti ai file .jar dell'Application Server).

Per ospitare tale programma su web e' necessario configurare correttamente il Java Web Server che lo ospita. La configurazione dipende dal prodotto utilizzato, viene spesso effettuata mediante pagine web di amministrazione o agendo su file di configurazione (spesso in formato XML). Ad esempio su JWS la configurazione si effettua su http://server/admin/servlet.html indicando il nome IloveYou e la classe IloveYouServlet. Il servlet sara' cosi pubblicato su http://server/servlet/IloveYou.
Su server piu' recenti (che aderiscano alle specifiche Servlet API Specification 2.2) la struttura di directory per il pubblishing delle applicazioni e' invece standardizzata e prevede una struttura di directory standard: WEB-INF, ... la distribuzione automatica delle applicazioni deployate come file .WAR, ...

Come funziona? Semplice!
O quasi... Quando il Web Server riceve la richiesta attiva la JVM del JRE configurato e fa eseguire il Servlet. L'output generato e' la risposta inviata al browser. Da questo punto di vista un Servlet e' molto vicino all'architettura delle applicazioni CGI ma con alcune importanti differenze... Sul server la JVM o le JVM sono sempre attive. I servlet vengono istanziati alla prima richiesta (init()), ogni richiesta attende il termine dell'inizializzazione quindi tutte vengono soddisfatte dalla stessa istanza di servlet ed il thread e' disponibile fino a che non viene richiamato il destroy(). Quindi, dal punto di vista prestazionale, l'attivazione di un servlet e' notevolemente piu' efficiente di un richiamo CGI.

Tutto qui? No: java, bytecode, architetture distribuite, servlet, classi fondamentali, RMI, ... Riferimenti: Ditelo con... Java, Ditelo con... JSP, ...

Ditelo con... JSP

Le Java Server Pages (JSP) sono state introdotte come un estensione delle API Servlet 2.1 ma e' piu' facile presentarle come partendo dall'HTML.
La scrittura di una pagine JSP e' infatti molto semplice e la sua lettura ricorda quella di una pagina HTML. Infatti si tratta di una pagina HTML/XHTML cui vengono aggiunte direttive JSP (include, page, taglib) introdotte con <%@, script JSP (declaration introdotte con <%! , scriptlet introdotte con <% , expression introdotte con <%= ) azioni JSP (include, forward, useBean, getProperty, ... introdotte con <jsp:include) ed eventuali TAG custom. Le possibilita' sono molte ma il risultato e' comunque piuttosto semplice, come si vedra' nell'esempio.

Dal punto di vista tecnico l'implementazione delle pagine JSP e' molto efficiente. La prima volta che viene richiamata la pagina JSP viene trasformata in un servlet, questo viene compilato e viene attivato un thread sull'Application Server. Sucessivi richiami utilizzeranno il thread, se ancora attivo, o il servlet corrispondente.

<html>
<head> 
<! Esempio in JSP> 
<title>Ditelo con... JSP</title> 
</head> 
<body> 
<% for (int i=0; i<3; i++) { %>
<p>Ti amo! 
<% } %>
</body> 
</html> 

Le pagine vengono realizzate con un normale editor HTML (personalmente uso il vi, ma dipende dai gusti ;-) e pubblicate ponendole su directory specifiche del web/app server. Tutto qui! Sara' il server che si occupa automaticamente di compilare le pagine quando necessario.

Tutto qui? No: HTML, servlet, java, ...

Ditelo con... JavaScript (browser)

JavaScript e' un linguaggio di scripting che viene interpretato dal browser e consente di "programmare" una pagina HTML. Con JavaScript e' possibile animare le pagine HTML, effettuare controlli e validazioni di dati, ...
Dal punto di vista sintattico JavaScript e' simile al linguaggio Java ma piu' perche' condividono radici nel linguaggio C e C++. Dal punto di vista tecnico le differenze tra Java e JavaScript sono talmente grandi che probabilmente l'unica cosa in comune e'... il nome! Un programma in JavaScript e' scritto direttamente all'interno di una pagina HTML (sotto forma di commento) ed e' di facile lettura e programmazione anche da parte di utenti non esperti.

Non vi sono differenze nel pubblicare su Web pagine che contengono Java Script rispetto a pagine HTML statiche.

Come funziona? Semplice!
Java Script e' semplicemente un'estensione dell'HTML. Poiche' si tratta di un'estensione procedurale, cioe' che consente di programmare, viene eseguita o meglio interpretata dal browser. Tutto qui.

Tutto qui? No: innanzi tutto va notata la grande differenza rispetto al linguaggio Java ed al suo uso in un applet: Si tratta di cose completamente differenti, anche se i termini (e la sintassi) si assomigliano!

Riferimenti: HTML, JavaScript, java, JSP, Node.js, MEAN, ...

Ditelo con... p5.js

p5.js e' una libreria Java Script ideata per la realizzazione di progetti grafici. E' di semplice programmazione e consente la realizzazione di progetti da parte di studenti, artisti, grafici, ricercatori, appassionati, ... p5.js utilizza praticamente stessa sintassi di Processing con il vantaggio di poter essere utilizzato in modo semplice ed interattivo in ogni pagina web.

p5.js viene esteso con librerie particolarmente potenti: p5.dom, p5.sound, p5.speech, p5.bot, p5.play, ...

Il punto di partenza e' una pagina web che contiene il riferimento allo sketch in Java Script:

 
function setup() {
}

function draw() {
  var i

  for (i=1; i<=3 ; i++) 
          text("Ti amo!",0,i*10);
}

Riferimenti: JavaScript (browser), JavaScript (linguaggio), ...

Ditelo con... VB Script

Visual Basic Script (VBS) e' un linguaggio di scripting che viene interpretato dal browser, dai mailer e da diverse altre applicazioni Microsoft e consente creare script che lanciano funzioni e macro sui diversi ambienti MS. Con VBS e' possibile animare le pagine HTML, effettuare controlli e validazioni di dati, inviare email, lanciare macro su MS-Word/Excel/..., ...
Dal punto di vista sintattico VBS e' simile al linguaggio Visual BASIC con un notevole utilizzo di oggetti e della relativa sintassi.

Questa pagina e' stata censurata poiche' un buontempone ha scritto in VB Script un simpatico worm dal titolo "I love You!" (forse aveva letto questo articolo??). Ma si e' confuso! Anziche' ripetere il messaggio 3 volte lo ha ripetuto su tutti i mailer Internet bloccando quasi la Rete per una giornata...

Come funziona? Semplice!
VB Script e' interpretato dal browser esattamente come Java Script... Quindi rileggetevi il capitoletto precedente!

Tutto qui? No: ... Riferimenti: ...

Ditelo con... Enterprise Java Bean

Gli Enterprise Java Bean (EJB) consentono di costruire architetture applicative distribuite complesse ed affidabili. Un EJB e' un componente riutilizzabile, portabile e gestito lato server.

L'EJB Container si occupa della gestione della sicurezza, delle transazioni, dei pool di connessione alle basi dati... e contiene tutti gli EJB istanziati.
L'EJB contiene quindi solo la "logica di business" dell'applicazione. Vi sono tre tipi di EJB:

• Session: esegue il task richiesto dal client
• Entity: rappresenta un oggetto su memoria persistente
• Message-Driven: per la gestione asincrona di messaggi

Le applicazioni che richiamano gli EJB invece si occupano della presentazione dei dati.

Con tale chiara separazione dei ruoli la costruzione di applicazioni distribuite complesse risulta semplificata. Infatti il programmatore si concentra nel realizzare la logica dell'applicazione senza occuparsi degli altri elementi al contorno che vengono forniti in modo automatico dal container.
L'utilizzo di un EJB da parte delle applicazioni che lo richiamano e' molto semplice. E' in pratica analogo al richiamo di un Java Bean. Il richiamo e' quindi immediato con i piu' comuni IDE che semplificano i dettagli dell'attivazione come l'RMI, il JNDI, il JAAS, ...

package oracle.ejb30; 
import javax.ejb.Remote;

@Remote public interface HelloWorld 
    {
        public void sayHello();
    } 

La definizione dell'interfaccia utilizza @Remote per indicare un'interfaccia remota.

package oracle.ejb30;
import javax.ejb.Stateless;

@Stateless public class HelloWorldBean implements HelloWorld 
    {
        public void sayHello()
            {
                int i;
    
                for (i=0; i<3; i++)                          
                     System.out.println("Ti amo!");
            }
    }

La classe bean implementa la logica di business. L'annotazione @Stateless indica che si tratta di un Stateless Bean.

Context context = new InitialContext(); 

HelloWorld helloWorld = (HelloWorld)context.lookup("java:comp/env/ejb/HelloWorld");
helloWorld.sayHello(); 

Ecco come l'applicazione richiama l'Enterprise Java Bean.

La modalita' di deploy e' molto importante. In modo simile ai servlet, gli EJB vengono distribuiti su file .EAR e debbono essere posti su un EJB Container.

Tutto qui? No: Java, Java Bean, RMI, ...

Ditelo con... un Portlet (JSP-168)

L'idea di base dei Portlet e' quella di realizzare applicazioni web che possono essere presentate all'interno di una piu' ampia pagina personale (un Web Portal). E' come il Portale fosse una pagina di giornale, personalizzabile per ogni utente, ed i Portlet i singoli articoli.
Il Portale si occupa di autenticare gli utenti, di effettuarne la profilazione, di definire il layout grafico. Il Portlet realizza la logica applicativa, che puo' essere una semplice presentazione di un testo, ma anche un programma vero e proprio.

Dal punto di vista tecnico un Portlet e' come un Servlet che, anziche' presentare un'intera pagina HTML, ne prepara una porzione. La parte esterna sara' infatti gestita dal Portale stesso. Dal punto di vista di autenticazione, profilazione, ... un Portlet deve richiamare i servizi offerti dal Portale cosi' come non puo' effettuare ridirezioni per non modificare il layout complessivo della pagina. In caso d'errore dovra' semplicemente segnalare il problema al Portale.
Anche dal punto di vista di programmazione la creazione di un Portlet e' analoga a quella di un Servlet. Si tratta di realizzare una serie di classi Java che implementano l'interfaccia prevista dallo standard. Lo standard prevede diversi stati del Portlet: View, Edit, Help, ... che corrispondono a diverse modalita' di visualizzazione del Portlet nel suo contenitore grafico. Nella classe Java del Portlet debbono quindi essere implementati i diversi metodi dell'interfaccia relativi alle modalita' di visualizzazione.

Nell'esempio che segue utilizzamo Java+JSP poiche' e' quella tipicamente piu' utilizzata. Il codice Java di implementazione del Portlet e':

public void doView (RenderRequest request,
                        RenderResponse response) throws PortletException, IOException
    {
        response.setContentType("text/html");        
        String jspName = getPortletConfig().getInitParameter("jspView");
        PortletRequestDispatcher rd = getPortletContext().getRequestDispatcher(jspName);
        rd.include(request,response);
    }

<%@ page session="false" %>
<%@ page import="javax.portlet.*"%>
<%@ page import="java.util.*"%>
<%@ taglib uri='/WEB-INF/tld/portlet.tld' prefix='portlet'%>
<portlet:defineObjects/>

<p>Ti amo!</p>
<p>Ti amo!</p>
<p>Ti amo!</p>

Portlet Mode: <%=portletRequest.getPortletMode()%>

I tratti di codice sono piuttosto semplici. Il deploy e' invece piu' complesso e richiede la compilazione di diversi file di configurazione (tipicamente .xml).

Lo strano nome JSR-168 e' dovuto al fatto che le API sono state sviluppate con il Java Community Process da parte di un'ampia serie di contributi (tra i principali: Apache, BEA, IBM, Oracle, SUN, ...).
Un altro importante standard sull'argomento e' il WSRP (Web Services for Remote Portlets) che descrive come debbono essere scambiati i dati tra le applicazioni (WSRP Producer) ed i portali (WSRP Consumer). I due standard sono complementari e sono spesso utilizzati entrambi.
Vi sono molteplici possibilita' di realizzare le funzionalita' di un portale. Molto diffusi sono, ad esempio, portali di Content Management che possono essere estesi con moduli... quella presentata in questo paragrafo e' la realizzazione di Portlet utilizzando le API Standard JSP-168 che e' maggiormente rivolta all'integrazione, alla sicurezza, ... per le altre architetture quando avro' un po' di tempo scrivero' qualcosa.

Tutto qui? No: Servlet, JSP, ...

Ditelo con... ASP

L'ASP (Active Server Pages) consente di programmare pagine HTML dinamiche. Le pagine create possono eseguire elaborazioni sia sul browser (come fa Java Script) che sul web server (come avviene con l'interfaccia CGI), effettuare controlli, leggere dati da DBs, ... Il codice ASP e' interpretato dal Web Server ed il risultato e' una pagina HTML "arricchita" con le informazioni ottenute.
Dal punto di vista tecnico le pagine ASP corrispondono alle pagine JSP, naturalmente... mutatis mutandis!

Anche l'ASP utilizza un'estensione del linguaggio HTML ed e' quindi richiamato con opportuni TAG. Le funzioni supportate non sono molte, ma ASP e' possibile richiamare funzioni scritte in Java Script ed in VB Script e' cosi' possibile fare di tutto.

Nel prossimo esempio l'ASP viene utilizzato per richiamare uno script in Java Script. L'aspetto interessante e' che il codice Java Script viene eseguito sul server quindi nulla di questo traspare alla pagina HTML finale inviata al browser (che quindi riporta sempre lo stesso romantico risultato).

Pubblicare una pagina ASP e' analogo a pubblicare una pagina HTML. Quindi molto facile. Ancora piu' facile che pubblicare uno script CGI. Se a questo aggiungiamo la "semplicita'" dei linguaggi di scripting utilizzabili si capisce perche' la creazione di pagine Internet dinamiche e' diventata una cosa molto comune. L'unica limitazione e' che l'ASP e' supportato solo da alcuni web server del mondo Microsoft (tra cui ovviamente IIS su NT).

Tutto qui? No: Internet Information Server, Internet Information Server: Active Server Pages, ADO (Active-X Data Object), tuning, ... Riferimenti: ...

Ditelo con... Node.js

Node.js e' un ambiente runtime Open Source che permette di ospitare applicazioni web e di networking scritte in Javascript.
Le applicazioni Node.js possono essere lanciate da linea di comando ma, in un ambiente di produzione, vengono tipicamente eseguite come servizio.

Se all'inizio Javascript era nato come linguaggio interpretato dai browser in breve tempo e' cresciuto molto come diffusione e potenzialita'. Node e' il programma dedicato all'esecuzione di applicazioni Javascript che utilizza un event loop su un unico thread ed offre ottime prestazioni grazie anche alla libreria libeio basata sul non blocking I/O.

// Node.js Javascript sample
var http = require('http');
var html = '';
var once = 'Ti amo!';

for (i = 0; i < 3; i++) {
    html += once + "<br>";
}
html += '';

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end(html);
}).listen(3000, '127.0.0.1');

L'applicazione e' semplicemente il file dimmelo.js e la si lancia con nohup node dimmelo.js & poiche' il nostro esempio e' un'applicazione web per accedervi da browser l'URL e' http://localhost:3000

Tutto qui? No: JavaScript, AngularJS, MEAN, Node-RED, ...

Ditelo con... Node-RED

Node-RED e' un ambiente di programmazione visuale che consente di programmare flussi di dati. Il suo uso principale e' quello di programmare flussi IoT (Internet of Things) ma l'accesso ad API esterne (eg. MQTT) e la programmazione delle funzioni con JavaScript lo rendono molto potente ed utilizzabile in ambiti differenti.

Le applicazioni vengono realizzate in modo visuale con un editor di flussi accessibile da un normale browser. Un flusso e' realizzato connettendo tra loro i nodi: tipicamente si parte da un nodo di input (Injection), si effettuano una serie di modifiche sul messaggio (Payload) con nodi di trattamento dell'informazione, fino ad arrivare ad un nodo di output (eg. Debug).
Dal punto di vista tecnico Node-RED e' basato su Node.JS ed i programmi (Flow) sono file JSON di cui viene effettuato il deploy sul sistema ospite. Il servizio per default e' attivo sulla porta 1800.
Per realizzare il nostro solito esempio di programmazione sono sufficienti i tre nodi riportati nella figura seguente:

Il loop e' implementato nella funzione che contiene una funzione JavaScript:

// Node-RED Javascript function

var i ;
var dimmi ="Ti amo!";
var dimmelo= [];

for (i=0; i<3 ; i++) {
  dimmelo.push({payload:dimmi});
} 

return [dimmelo];

Per eseguirlo basta iniettare un valore e sulla console apparira' il nostro romantico messaggio per tre volte!

Tutto qui? No: Node.js, JavaScript, ...

Ditelo con... MATLAB App Designer

App Designer e' l'ambiente grafico per realizzare GUI (Graphical User Interface) con MATLAB.
Il linguaggio di programmazione MATLAB e' un linguaggio intepretato, ad oggetti con classi ed erditarieta', debolmente tipato, rivolto sopratutto al calcolo matriciale: le variabili sono tutte vettori di strutture. Nel calcolo matriciale MATLAB e' effettivamente potente e trova cosi' utilizzo in molti rami della matematica, del controllo e dell'ingegneria.

Poiche' e' rivolta agli ingegneri l'interfaccia di programmazione App Designer e' semplificata :)
Vengono posizionati con il drag&drop i componenti grafici dell'applicazione e quindi programmati i callback in modo guidato.

L'applicazione puo' essere eseguita in locale, come nella figura sotto, ma anche compilata ed utilizzata come applicazione standalone o pubblicata su web.

Tutto qui? Si!

Ditelo con... Stitch

Stitch e' la piattaforma Cloud che consente di sviluppare applicazioni serverless che accedono a dati MongoDB.
Stitch consente di definire le Rule di accesso ai dati MongoDB e di far accedere a questi da applicazioni Web o Mobile. E' inoltre possibile definire Function e Trigger eseguite sulla piattaforma che implementano la logica applicativa.

L'applicazione e' realizzata con una serie di richiami JavaScript contenuti in un normale file HTML. Al caricamento della pagina viene richiamata una funzione JavaScript che si collega a Stitch ed esegue una ricerca su MongoDB Atlas che trova il nostro dolce messaggio.

Tutto qui? No: HTML, JavaScript, MongoDB, ...

Ditelo con... Roblox

Roblox e' un'interessante piattaforma di gioco dove si possono creare mondi virtuali, dove si puo' socializzare con altri utenti e dove e' possibile acquistare, vendere e creare oggetti virtuali. Apparentemente e' solo un gioco ma gli avatar, l'interazione sociale e la presenza di molteplici mondi 3D fanno di Roblox un esempio classico di Metaverso.

Roblox e' un MMO (massively multiplayer online game) utilizzato da milioni di utenti che giocano su milioni di applicazioni differenti. Lo sviluppo delle applicazioni si effettua con Roblox Studio che ha un'interfaccia grafica molto completa e complessa che consente la programmazione delle interazioni tra oggetti mediante script LUA.
Ma il nostro solito esempio e' comunque semplice:

-- Script Lua in Roblox

i = 0
      while i < 3 do
        print("Ti amo!")
        i = i+1
      end

L'utilizzo di Roblox Studio e' gratuito e chiunque puo' pubblicare le proprie applicazioni in modo molto semplice per i propro amici o per tutti.

Tutto qui? No: LUA, Luau, ...

Ditelo con... Telegram Bot

Telegram e' una potente applicazione di messaggistica che utilizza il cloud per le comunicazioni. I client sono Open Source e sono disponibili su Smatphone, tablet, PC, ... Tra le molte funzionalita' sono possibili trasmissioni punto-punto crittografate.

Un Bot in Telegram e' un programma che si sostituisce ad un utente ricevendo ed inviando messaggi. Le Bot API sono molto potenti e consentono di realizzare vere applicazioni inline.
Ma il nostro solito esempio e' comunque semplice:

<?php
$content = file_get_contents("php://input");
$update = json_decode($content, true);

$chatId = isset($message['chat']['id']) ? $message['chat']['id'] : "";
$text = "Ti amo!\nTi amo!\nTi amo!";

header("Content-Type: application/json");
$parameters = array('chat_id' => $chatId, "text" => $text);
$parameters["method"] = "sendMessage";
echo json_encode($parameters);
>

Il bot deve essere registrato utilizzando il @BotFather e quindi va impostato un WebHook al servizio web che lo implementa. Il servizio web puo' essere implementato praticamente con qualsiasi linguaggio: nell'esempio abbiamo utilizzato il PHP che ha una sintassi molto semplice ed a cui e' sufficiente una piattaforma LAMP.

Sono passati una decina di anni ed ho nuovamente avuto bisogno di un bot... questa volta ho utilizzato il python:

import telegram_send

telegram_send.send(messages=["Ti amo!\nTi amo!\nTi amo!"])

Tutto qui? No: PHP, LAMP, ...

Ditelo con... Motion AI Bot

Motion AI e' una piattaforma che consente di sviluppare Bot in modo molto semplice. Il software e' chiuso e l'utilizzo non e' gratuito ma si possono provare liberamente tutti gli strumenti di programmazione se producono un traffico limitato.
Sono supportati i piu' importanti canali tra cui: WebChat, eMail, SMS, Facebook Messenger, ...

Un'interazione con l'utente e' costituita da diversi moduli che hanno il compito di raccogliere i dati ed analizzarli con tecniche di AI (Artificial Intelligence). Per gestire comportamenti piu' complessi si utilizza un WebHook a cui vengono indirizzate tutte le richieste. Uno dei moduli disponibili utilizza Node.js per analizzare i dati utente:

exports.handler = (event, context, callback) => {
    var responseJSON = {
        "response": "Ti amo!\nTi amo!\nTi amo!", 
        "continue": true,
        "customPayload": "", 
        "quickReplies": null,  
        "cards": null, 
        "customVars": null, 
        "nextModule": null 
    }

    callback(null, responseJSON);
};

La creazione dei Bot e la sequenza dei moduli viene effettuata con una semplice interfaccia Web che consente una semplice programmazione delle risposte.

Tutto qui? No: Node.js, ...

Ditelo con... Solidity

Solidity e' propriamente un linguaggio di programmazione, nonostante questo l'ho inserito nella categoria delle architetture perche' e' questa la parte piu' interessante. Solidity e' un linguaggio Open Source sintatticamente simile a JavaScript; come molti linguaggi e' Turing completo, ma l'esecuzione di un programma ha un limite massimo di "gas" da poter utilizzare.

Con Solidity si programmano gli Smart Contracts sul blockchain Ethereum. Ethereum e' una criptovaluta, come la piu' famosa Bitcoin, da cui si distingue per due ragioni tecniche: non c'e' un limite massimo al numero di Ethereum in circolazione ed Ethereum consente di effettuare gli scambi con Smart Contract ovvero applicazioni scritte in Solidity che operano sui server che ospitano la blockchain.
Per entrambe le criptovalute viene utilizzato il concetto di blockchain: un database costituito da blocchi di transazioni. Ogni transazione contiene un timestamp, ogni blocco contiene l'hash del blocco precedente. L'intera catena e' accessibile a tutti i server, tipicamente pubblici, garantendo cosi' la completa trasparenza su ogni operazione e le transazioni non hanno costi [NdA in realta' c'e' il costo del mining necessario per i complessi calcoli di crittografia, ma e' molto limitato].

Uno Smart Contract, per Solidity, e' una collezione di codice (le sue funzioni) e di dati (il suo stato) che e' mantenuto sulla blockchain Ethereum:

pragma solidity ^0.4.0;

contract Dimmelo {
    uint storedData=0;
    string phrase="Ti amo!";

    function dimmi() returns (string) {
        storedData += 1;
        return phrase;
    }
}

Per provare semplici applicazioni e' possibile utilizzare Remix che e' un'IDE completa disponibile da browser. Per un'installazione completa della bitchain la piattaforma Node.js e' la piu' utilizzata.

Se qualcuno se ne fosse accorto: non ho concatenato volutamente per tre volte la solita stringa perche'... non c'e' ancora una funzione di concatenzione in Solidity!

Tutto qui? No: JavaScript, Node.js, ...

Ditelo con... un Cartridge PL-SQL

Alcuni web server consentono di sviluppare applicazioni in ambienti ed architetture particolari. L'OWS (Oracle Web Server) utilizzando il Cartridge PL-SQL permette di generare pagine HTML programmando in PL-SQL.
Per programmare una pagina in PL-SQL e' sufficiente creare una stored procedure o un package utilizzando alcuni package di estensione dell'PL-SQL (eg. ht).

create procedure dimmelo is
declare
        i number;

begin
for i in 1..3 loop
        ht.print( '<p>Ti amo!');
end loop;
end;

Come si vede dall'esempio la programmazione in PL-SQL e' molto semplice. Con la procedure ht.print e' possibile scrivere un testo qualsiasi che naturalmente fara' parte della pagina HTML inviata all'utente. Per richiamare la pagina sara' sufficiente utilizzare l'URL che accede al Cartrige PL-SQL ed alla connessione di database corretta (eg. http://www.xyz.it/ag_dbdemo/plsql/dimmelo dove ag_dbdemo e' l'agent che accede al DAD della base dati che ospita la stored procedure dimmelo... ma questi sono aspetti di interesse per la configurazione dell'ambiente e non per la programmazione). NB. www.xyz.it non esiste!

Vi siete aggiornati e state utilizzando Oracle9iAS? Beh sono cambiati acronimi, versioni, architettura, funzionalita', ... ma molte cose sono simili.
I package per l'output su web e' htp anziche' ht, per richiamare la stored procedure utilizzerete invece http://www.xyz.it/pls/dad_name/dimmelo (dove il dad_name e' il nome del DAD). Poi c'e' il mondo dei portali...

Tutto qui? No: PL-SQL, SQL, HTML, ... Riferimenti: Oracle Web Server, ...

Ditelo con... External Procedure Oracle

L'RDBMS Oracle puo' essere, gia' molto completo come funzionalita', puo' essere arricchito con funzioni esterne. Tali funzioni vengono compilate in una libreria che, opportunamente dichiarata, puo' essere richiamata da Oracle con i normali statement SQL.

La difficolta' non e' nella programmazione ma nei diversi passaggi di configurazione da effettuare... quindi, per questo esempio, procederemo per fasi.
Innanzi tutto bisogna fare un bel programma in C:

#include 
#include 

int dimmelo (char stringa[])
{
  int len;

  len = strlen(stringa);
  strncpy(stringa, "Ti amo!\nTi amo!\nTi amo!", len-1);
}

Il programma va compilato ed inserito in una libreria dinamica. Per farlo (su Linux) i comandi sono: gcc -fPIC -g -c dimmelo.c e quindi gcc -shared -o dimmelo.so dimmelo.o -lc.

Il richiamo delle procedure esterne avviene mediante il TNS. Vanno quindi configurati il listener.ora:

 SID_LIST_LISTENER_ORCL =
  (SID_LIST =
   (SID_DESC =
    (SID_NAME = PLSExtProc_ORCL)
    (ORACLE_HOME = /home/app/oracle/product/10g)
    (PROGRAM = extproc)
    (ENVS="EXTPROC_DLLS=ANY,LD_LIBRARY_PATH=/home/app/oracle/product/10g/lib:/usr/oracle/")
   )
     (SID_DESC =
       (SID_NAME = ORCL)
       (ORACLE_HOME = /home/app/oracle/product/10g)
     )
  )

 LISTENER_ORCL =
   (DESCRIPTION_LIST =
     (DESCRIPTION =
       (ADDRESS = (PROTOCOL = TCP)(HOST = dbserver.xenialab.it)(PORT = 1569))
       (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC_ORCL))
     )
   )

e tnsnames.ora:

 EXTPROC_CONNECTION_DATA =
  (DESCRIPTION_LIST =
   (DESCRIPTION =
    (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC_ORCL))
    (CONNECT_DATA = (SID = PLSExtProc_ORCL) (PRESENTATION = RO))
   )
  )

All'interno di Oracle la libreria esterna va dichiatata con:

create or replace library system.dimmelo
 is '/usr/oracle/dimmelo.so'
/

Ora si puo' creare una procedura con:

create or replace procedure system.dimmi (sr IN OUT string )
 is external name "dimmelo" library dimmelo language C parameters (sr string);
/

Finalmente si puo' richiamare la procedura! Per farlo utilizziamo un blocco PL-SQL anonimo:

SET SERVEROUTPUT ON
/
DECLARE
stringa varchar2(100) := '------------------------------';

BEGIN
    DBMS_OUTPUT.PUT_LINE('Prima: ' ||  stringa );
    system.dimmi( stringa );
    DBMS_OUTPUT.PUT_LINE('e Poi: ' || stringa);
END;
/

Facile vero?

Tutto qui? No: C, SQL, PL-SQL, ...

Ditelo con... Cache'/SOAP

SOAP e' un protocollo molto pulito!
Ma bisogna fare attenzione a non scivolare sulle sigle...

SOAP (Simple Object Access Protocol) e' un protocollo basato sull'HTTP (HyperText Transfer Protocol) tra applicazioni che utilizzano l'XML (eXtented Markup Language) per inviare richieste e risposte.
Le richieste possono essere inviate ad un SOAP Server che pubblica l'elenco dei servizi forniti con un documento WSDL (Web Services Description Language). Le richieste vengono inviate dai SOAP Client.

Qualche notizia in piu'...
Il protocollo SOAP e' stateless. Ogni XML WS deve utilizzare un namespace unico per distinguerlo da tutti gli altri. Il namespace e' un URI (che sono i cugini bizzarri degli URL).
Le idee di base sono molto semplici ed, utilizzando un IDE, e' anche semplice sviluppare applicazioni. Ma si tratta di concetti molto potenti che consentono di realizzare un architettura SOA (Service Oriented Architecture).

L'esempio che segue e' stato realizzato con Cache'. Cache' e' uno strumento RAD che unisce un DB relazionale con un profondo utilizzo dell'object oriented e dei servizi su web. Con questo strumento vengono create delle pagine CSP (Cache' Server Pages) realizzate con un linguaggio object oriented con un accesso diretto ai dati. Tramite un semplice wizard e' possibile creare Web Service SOAP.

/// Esempio di Web Service SOAP in Cache'
Class Parole.Dimmelo Extends %SOAP.WebService [ProcedureBlock]
{
Parameter SERVICENAME = "Dimmelo";
Parameter LOCATION = "http://127.0.0.1/csp/samples";
Parameter NAMESPACE = "http://tempuri.org";

ClassMethod Test() As %String [ WebMethod ]
 {
        set frase=""
        
        for i=1:1:3
         { 
         set frase= frase _ "Ti Amo! "
         }
        Quit frase
 }
}

Tutto qui? No: HTML, XML, SOAP (PHP), ... Riferimenti:

Ditelo con... SOAP (PHP)

Tutta la storia del SOAP ve la siete gia' letta nel paragrafo precedente... quindi ve la risparmio!
Vediamo quindi un altro esempio relizzato con uno dei linguaggi piu' semplici e produttivi utilizzati per applicazioni web: il PHP. Il SOAP Server (tiDico.php) si implementa con queste semplici istruzioni:

<?php
require_once('nusoap/lib/nusoap.php');

$ns="http://myhost.mydomain/soap_demo/tiDico.php";
$server = new soap_server();

$server->configureWSDL('Dimmi',$ns);
$server->wsdl->schemaTargetNamespace=$ns;

$server->register('Dimmi',array(), array('Frase' => 'xsd:string'),$ns);

function Dimmi() {
        $retval='';
        for ($i=0;$i<3;$i++) {
        $retval = 'Ti amo! '.$retval ;
        }
    return $retval;
}

$HTTP_RAW_POST_DATA = isset($HTTP_RAW_POST_DATA) ? $HTTP_RAW_POST_DATA : '';
$server->service($HTTP_RAW_POST_DATA);
?>

Nell'esempio viene utilizzata la libreria nusoap che fornisce i metodi per registrare i servizi SOAP e per richiamarli. Tutta la complessita' del protocollo, l'XML, i messaggi, ... vengono gestiti dalla libreria nel modo previsto dagli standard.
Il server definisce un serizio SOAP, configura lo schema WSDL e registra il metodo Dimmi definendone i parametri di input e di output. A questo punto debbono essere implementati tutti i metodi definiti... il vero e proprio "lavoro" e' tutto nel richiamo di server->service() che restituisce quanto richiesto da chi richiama il servizio.

Il servizio puo' essere richiamato in modo molto semplice da un SOAP Client (dimmi.php):

<?php
require_once('nusoap/lib/nusoap.php');

$client = new soapclient('http://myhost.mydomain/soap_demo/tiDico.php?wsdl',true);

$result = $client->call('Dimmi', array());
print $result;
?>

Anche il client e' molto semplice... utilizzando le opportune librerie deve sono richiamare il metodo desiderato passando i parametri corretti, gestirne gli eventuali errori (non riportati nell'esempio) ed ottenere il risultato.

Compilazione, installazione, configurazione, tuning?
Con il PHP e' tutto molto semplice: basta copiare script e libreria sul proprio web server (purche' supporti il PHP), modificare l'URL ed e' tutto fatto!

Tutto qui? No: SOAP, HTML, XML, PHP, ...

Ditelo con... Jython e con il Grinder

Jython e' l'implementazione Java di Python.
Non ci sarebbe molto da dire poiche' e' analogo al Phython... ma noi ne approfittiamo per mostrare un esempio di script in Jython utilizzato con Grinder.
Grinder e' un tool Free Source per effettuare test di carico su applicazioni web (e non solo). Per programmare test run utilizza il Jython:

from net.grinder.script.Grinder import grinder
from net.grinder.script import Test

log = grinder.logger.output

test1 = Test(1, "I Love You Test")

logWrapper = test1.wrap(log)

class TestRunner:
    def __call__(self):
        for i in range (3):
                logWrapper("I love You!")

Grinder e' un tool molto potente... ma in questo caso, lanciando java net.grinder.Grinder, nel log si trovera' qualcosa di romantico!

Tutto qui? No: Java, Python, Grinder, ... Riferimenti:

Ditelo con... COM/ActiveX

Il COM (Component Object Model) e' un'architettura introdotta da Microsoft per lo sviluppo di applicazioni ad oggetti e distribuite (nella sua evoluzione). COM e' spesso indicata anche con il nome ActiveX che, in realta', indica un componente specifico dell'architettura COM.

Sui dettagli dell'architettura e la sua storia (OLE, COM, DCOM, COM+)... no comment! Ma l'utilizzo, anche se non sempre semplice, e' molto produttivo.

import sys
import win32com.client
speaker = win32com.client.Dispatch("SAPI.SpVoice")
s = 'Ti hamo!'
try:
    for i in range(3):
        speaker.Speak(s)
except:
    if sys.exc_type is EOFError:
        sys.exit()

Nell'esempio viene richiamato un semplice servizio che parla da uno script Python. La pronucia e' piuttosto pittoresca...
Per eseguire l'esempio, oltre all'interprete Python, e' necessario installare il package win32com. Con tale interfaccia Python puo' richiamare quasi ogni programma COM (ad esempio MS-Word, MS-Excel, ...), scrivere server ospitati da client COM, ...

Tutto qui? No: python, DCOM, COM+, MTS, MSMQ, OLE, OCX, ...

Ditelo con... l'UML

L'UML (Unified Modeling Language) e' un linguaggio per la modellizzazione degli oggetti e la definzione di specifiche. L'UML nella sua totalita' e' molto complesso e completo e molti, come il sottoscritto, ne conoscono discretamente solo alcune parti ma utilizzano comunque la notazione grafica.

Per chi ha qualche interesse in piu'... Le parti principali di un modello di un sistema sono 3:

• Functional Model
• Object Model
• Dynamic Model

Questi modelli vengono rappresentati mediante diagrammi. Ve ne sono 13 (per lo standard UML 2.0) raggruppati come segue:

• Structure Diagrams
  • Class diagram
  • Component diagram
  • Object diagram
  • Composite structure diagram
  • Deployment diagram
  • Package diagram
• Behavior Diagrams
  • Activity diagram
  • Use Case diagram
  • State Machine diagram
• Interaction Diagrams (subset di Behavior Diagrams)
  • Sequence diagram
  • Collaboration/Communication diagram
  • Interaction overview diagram
  • Timing diagram

Ma abbiamo parlato troppo, torniamo all'argomento principale! Nell'esempio e' rappresentato un "flowchart" del nostro classico esempio.

In realta' l'Activity Diagram utilizzato puo' rappresentare molti piu' elementi di un flowchart. La semantica del diagramma e' infatti quella delle reti di Petri ed e' possibile rappresentare attori e ruoli... Ma per ora basta cosi!

Ditelo con... i fiori

Se davvero dovete dire "Ti amo" allora ditelo con i fiori!
Si tratta di un linguaggio universale, ad oggetti, da interpretare ed interpretato ma qualche volta incompreso, di notevole diffusione e compatibile i18n ed L10n.

Per rimanere nell'esempio comprate tre rose rosse! ;-)

E se temete di confondervi con le parole alla consegna del mazzo... beh scrivete un bigliettino!

Ditelo con... l'Ikebana

Una versione assai sofisticata ed artistica del linguaggio dei fiori e' quella giapponese: l'ikebana. Anche di questa particolare versione del linguaggio c'e' parso opportuno riportare un esempio.

Per le regole di compilazione di un ikebana si rimanda alla documentazione tecnica specifica!

Ditelo con...

Le vie dell'informatica sono infinite (come il nastro della macchina di Turing). Ed allora perche' non citare anche gli altri...

• linguaggi: ASSEMBLER (altri dialetti: ogni familia di processori ha il suo), Toscano (con i dialetti livornese e pisano che e' noto siano incompatibili tra loro), ...
  
• ambienti: JCL, SAP/ABAP, BAAN, VBA: Visual Basic for application, NASL, NoSQL, AR (Augmented Reality), ...
  
• architetture: cgi (in altre mille altre "salse"), RMI socket factory, J2ME, ODBC, CORBA, .NET, X-Window (Xt intrinsics), MS-Windows, IS-API, NS-API, Browser Plug-in, PRO*Cobol, VMware, VNC, protocollo WSRP (producer, consumer), JSR-168 (Portlet), JSR-170 (Content Management), JSR-286 (Portlet 2), Struts, HTTP tunneling, JNDI, CSS, Facebook, LabVIEW, G, Ruby on Rails, ...

Se pensate che io sia l'unico matto che scrive di queste cose... vi sbagliate!

Nella Torre di Babele gia' si parlavano tutti i linguaggi ed e' noto che qualche difficolta' ci sia stata... i pareri su come sia andata veramente sono in parte discordi ma ne hanno scritto anche nella Bibbia (che e' uno dei libri piu' noti)!
Un referto storico concreto e' la Stele di Rosetta, una lastra conservata al museo del Louvre con lo stesso testo riportato in piu' linguaggi (imperativi ed interpretati per essere precisi).

Nell'era del Web trovare i documenti e' molto piu' semplice: sono molti gli articoli simili a questa paginetta che ho trovato pubblicati (ovviamente in inglese).
Simpatica e' l'evoluzione di un programmatore. Per i piu' curiosi, un po' di geneaologia e :-( una pagina quasi identica a questa e piu' completa... ma assai meno romantica di questa!

Titolo: Hello World... ditelo con i fiori
Livello: Medio (2/5)
Data: 14 Febbraio 1999
Versione: 1.3.34 - 1 Aprile 2024
Autore: mail [AT] meo.bogliolo.name

Dedicato: ... a te! ;-)