Analisi personale della riforma costituzionale

Ho deciso di leggere il testo della riforma costituzionale che dovremo votare il 4 Dicembre. Tutto il testo, per intero, e queste sono le cose che ho notato:

  • Prima l’ente “Unione Europea” veniva nominato una volta sola, ora viene nominato quasi quanto “Stato” [disapprovo, non siamo uno Stato Federale, se lo fossimo, potrebbe pure andare bene];
  • Prima gli articoli erano più semplici e comprensibili, ora sono più lunghi e complicati, con lunghe liste di chi fa cosa e chi no e come [non sono un esperto, ma mi sembrano tutti spunti ottimi per appigli legali];
  • Cito dal testo della riforma: “Su proposta del Governo, la legge dello Stato può intervenire in materie non riservate alla legislazione esclusiva quando lo richieda la tutela dell’unità giuridica o economica della Repubblica, ovvero la tutela dell’interesse nazionale.” In pratica, se ho ben capito, la Camera dei deputati potrebbe “a sua discrezione” stabilire che ci si trova in una situazione di emergenza, facendosi carico anche degli altri poteri dello Stato. Suona un po’ come un presupposto adatto ad una deriva autoritaria.

Queste sono le cose che, analizzate personalmente dal testo della riforma, senza alcun intermediario, vedo estremamente negative.

Qualche video pro riforma mi aveva fatto precedentemente pensare che qualcosa di buono ci fosse, e in effetti c’è, ma sono piccolezze messe fin troppo in risalto. Sì, qualche senatore in meno (molti senatori in meno), non ci sarebbero più le regioni [ci sarebbero le città metropolitane], la Camera avrebbe poteri maggiori [sarà davvero una cosa positiva questa?], meno se non nulli i limiti di età per governo ed elettori [sarà davvero una cosa positiva questa?].

Leggendo il testo della riforma, mi sono fatto una mia personale opinione, priva di tendenze partitiche, e ho deciso cosa votare: NO.

Trovate in allegato il testo della riforma.

Lettera ai cittadini baresi.

La pista ciclabile è una strada, non è pedonale e le auto non hanno la precedenza.

La prossima volta che tu, madre con la figlia piccola di forse 3 anni, deciderai di attraversare la pista ciclabile, ricordati che è una strada! Chissà, magari la prossima volta i miei riflessi non saranno così buoni, e tua figlia potrebbe essere l’ennesimo cadavere in mezzo alla strada. E la colpa sarebbe solo tua, che non hai guardato prima di attraversare, non mia.
 
Lo stesso vale per tutti voi che camminate allegramente sulla pista ciclabile come fosse il marciapede (che poi, magari, sul marciapiede subito accanto non c’è nessuno). La prossima volta, con qualcuno più distratto di me, le vostre budella potrebbero essere per terra. Sì, perché oggi in bicicletta si arriva anche a 30-40km/h; io ci arrivo così da solo, qualcuno più anziano con l’aiuto della pedalata assistita. E magari queste persone più anziane non hanno i miei riflessi.
 
Come dici? Questo discorso non ti riguarda? Fai sempre attenzione?
 
Aspetta.
 
Sei forse tu quel deficiente con la macchina che si è buttato nel fare inversione su via Unità d’Italia, senza guardare prima, e poi mi ha strombazzato urlando come un dannato? Beh, sappi che la prossima volta (come è già accaduto ben 2 volte) io potrei venirti addosso con la mia bella ruota rinforzata da mountain bike, e lasciarti la forma della bicicletta nello sportello, causando migliaia di euro di danni. E sappi che dovrai stare muto, perché la colpa è tua.
 
A te pedone che cammini sulla pista ciclabile come fosse marciapiede.
A te automobile che ti butti sulla pista ciclabile pensando di avere la precedenza.
La prossima volta potrebbe non andarti così bene, e davanti a te che piangi io dirò “ben ti sta”, perché sei stato avvisato.

La classificazione degli “esperti” informatici

L’informatica è una materia strana. Così vasta che nessuno potrebbe comprenderla appieno, così popolare che tutti si credono esperti. Purtroppo, al di là degli utenti che non ne capiscono nulla e lo ammettono, esistono molte tipologie di falsi “esperti” che si comportano come se sapessero tutto sui computer, sul mondo degli smartphone e tablet, sul mondo hardware e software.

Col tempo, ho organizzato una mia divisione in categorie degli “esperti”, che lo siano davvero o meno, e ho deciso di condividerla con voi.

  • Il vecchietto – (così chiamato perché si tratta per la maggior parte di persone anziane o dure di comprendonio) Questo mistico essere vede il computer come una scatola magica capace di fare tutto ciò che dice. Se una volta riesce a collegarsi ad Internet, crede di aver dominato il Web, e di sapere ormai tutto. Se gli si chiede di rifarlo, è possibile che non ci riesca. Quando il computer si rompe e chiama un vero tecnico, chiede mille spiegazioni, che non è in grado di capire, e si arrabbia. Se gli vengono invece raccontate frottole più comprensibili, le accetta di buon grado e le ripete a pappagallo ad amici e parenti come sacrosante verità.
  • Il superutente – Usa il pc, non sa e non capisce come facciano le cose a funzionare, legge guide passo passo, installa tantissimi programmi inutili per fare le cose più semplici, prende virus in continuazione. Tuttavia, il superutente sa come usare Word, Excel, Powerpoint e Facebook: abbastanza da dare consigli agli amici incapaci su come stampare quattro immagini su una slide.
  • Lo smanettone – Ha compreso la logica dei programmi e si adatta senza sforzo per tentativi a quelli nuovi. Per gli amici lui è “quello bravo col PC”. Ogni volta che il computer si blocca perde ore a cercare tool antivirus sul blog di Aranzulla. A volte risolve il problema, altre volte corre a piangere da un tecnico, a cui puntualmente fa saltare i nervi con migliaia di domande e criticando il suo modo di agire. Alla fine, però, è lui a pagare il tecnico per riparare il PC.
  • Il tecnico software – Installa e disinstalla i programmi nel modo corretto, sistema il pc con pulizia, antivirus, deframmentazione ed eventualmente formattazione. Configura le reti e sa usare correttamente il pannello di controllo di Windows. Sempre fissato con le copie di backup.
  •  Il tecnico vero e proprio – Quando al pc accade qualcosa sa capire subito se è un problema di registro, cosa dove come un virus può aver colpito, toglierli senza usare tool né antivirus, associare subito malfunzionamenti software a eventuali problemi hardware. Costui è il primo che può veramente definirsi esperto, non comprende appieno perché certe cose si comportino in un modo piuttosto che in un altro, ma sa come gestire tutto in maniera che funzioni adeguatamente.
  • Lo sviluppatore – che il software (se non anche l’hardware) lo crea e lo capisce meglio di chiunque altro. Gli sviluppatori privilegiano, per la maggior parte, l’approccio distaccato dagli utenti. Il loro computer è sempre funzionante, pieno di righe di codice e di bozze di idee. Non aiutano le categorie inferiori per vantarsi delle proprie capacità, lo fanno solo di malavoglia o dietro cospicuo pagamento. Al contrario, si scambiano una notevole quantità di informazioni fra loro, nel tentativo di migliorarsi a vicenda.
  • Infine gli “stregoni del codice”, o hacker propriamente detti (Il significato del termine è stato fortemente distorto dai media, associato ai crackers [o black hat hackers]) – Persone che riescono a vedere il codice con cui è fatto un programma osservandone il funzionamento, e riprodurlo o modificarlo, a prescindere dal linguaggio di programmazione. Costituiscono il livello massimo di comprensione a cui un qualsiasi appassionato di informatica possa aspirare.

Naturalmente, ritengo che solo chi appartiene alle ultime tre categorie possa essere definito esperto. E che solo chi appartiene alle ultime due ha la capacità di creare applicazioni. Chi si vanta di creare app, utilizzando solo tool automatizzati e senza scrivere una riga di codice, non è uno sviluppatore. Chi copia e incolla i seriali e i crack dal web, senza mai aver modificato il codice di un programma, o averlo “bucato”, non può ritenersi un hacker.

Quanto a me, mi ritengo uno sviluppatore, anche se ho sempre coltivato il mito degli hacker e sempre voluto diventarne uno.

Se vi riconoscete in una delle precedenti categorie, o se vi riconoscete un vostro amico, vi invito a esprimere la vostra opinione in merito e/o a suggerire nuove classificazioni di questo essere mistico chiamato “l’informatico”.

Copyright immagine in evidenza © Freepik

Automi a stati finiti

Completando il post precedente sulle espressioni regolari, riassumo ed esplico ciò che mi è sembrato più ostico dell’esame di fondamenti di informatica.

Gli automi a stati finiti sono dei concetti matematici rappresentabili mediante dei grafi, e come tali costituiti da un insieme di nodi ed archi. Altri esempi di grafi sono le mappe delle linee di una metropolitana o dei treni, o ancora l’albero delle cartelle in un sistema operativo. Gli elementi del grafo sono i nodi, e questi sono raggiungibili mediante archi a partire da altri nodi.

In un automa a stati finiti, ogni nodo corrisponde ad uno stato dell’automa e ogni arco un passaggio tra stati. L’automa ha uno stato iniziale, rappresentato da una freccia entrante nel nodo, e uno stato finale, rappresentato da una doppia circonferenza. Il grafo che rappresenta l’automa si dice diagramma di transizione.

L’automa si dice a stati finiti perché ha un numero finito di stati, si dice deterministico se può esserci, a partire da un qualsiasi stato, soltanto un arco che porta ad un altro stato a causa di un determinato evento.

Ecco un esempio di automa a stati finiti deterministico:

automa_zeripari

Tale automa accetta solo stringhe che contengono un numero pari di 0 e un numero pari di uno. L’insieme degli stati è finito: . Lo stato iniziale è , lo stato finale è sempre . L’alfabeto dell’automa è . Ognuno degli stati ha una ed una sola freccia avente simbolo 1, una ed una sola freccia avente simbolo 0, quindi l’automa è anche deterministico.

L’insieme delle stringhe accettate da un automa deterministico a stati finiti può essere rappresentato mediante una espressione regolare. Ad esempio, l’espressione regolare denota il seguente automa:

fsa_zeo_uno

 

Chiaramente, tale modello di automa non si limita, nell’applicazione, alla sola informatica.

Espressioni regolari o algebra di Kleene

Di tutti i problemi che mi ha creato l’esame di fondamenti di informatica, quello di gran lunga maggiore è stato causato dalle espressioni regolari. Il mio libro non ne parlava e non si trovava documentazione sufficiente online né su queste né sugli automi, così sono stato costretto a mettere insieme i pezzi da diverse fonti. Riporterò ora qui ciò che sono riuscito a capire, per comodità degli studenti futuri.

Supponiamo di avere a disposizione un insieme di simboli, ad esempio:

Tale insieme si chiama alfabeto. Scopo delle espressioni regolari è definire un sottoinsieme (finito o infinito) di combinazioni possibili utilizzando tali simboli. Per esempio l’insieme dei simboli che contiene soltanto oppure l’insieme che contiene soltanto ripetuto tante volte. Ogni elemento definito da una espressione regolare si dice stringa, alcune espressioni regolari possono permettere l’esistenza di una stringa priva di simboli, detta stringa vuota (che denoteremo con ε).

Per costruire le stringhe, si utilizzano dei simboli riservati (detti operatori), che non possono far parte dell’alfabeto.

Il primo e il più semplice è il simbolo di concatenazione, ovvero il punto, che può anche essere omesso:

Questo sottoinsieme di stringhe è dunque formato dalla sola stringa .

L’operatore unione (simbolo +) permette di scegliere alternativamente un simbolo oppure un altro:

oppure 

Il simbolo * denota un particolare operatore chiamato Stella di Kleene, che indica la concatenazione ripetuta n volte (con n che va da zero a infinito) di una data stringa:

Utilizzando contemporaneamente più operatori è possibile definire qualsiasi sottoinsieme di stringhe dato un qualsiasi alfabeto di partenza, costruendo espressioni regolari sempre più complesse.

Spero di essere stato sufficientemente chiaro!

La verità della vita I

Senza sacrificio l’uomo non può ottenere nulla. Per ottenere qualcosa è necessario dare in cambio qualcos’altro che abbia il medesimo valore. In alchimia è chiamato “il principio dello scambio equivalente” A quel tempo, noi eravamo sicuri che fosse anche la verità della vita.

E sì, sono un fan di Fullmetal Alchemist.

Corona SDK – Le basi – Lezione 3: il primo pulsante

Nella scorsa lezione abbiamo visto un semplice Hello, World! in Corona SDK. In questa lezione creeremo il nostro primo pulsante e incrementeremo un valore visualizzato ogni volta che lo premiamo.

Innanzitutto inseriamo vediamo l’header del file:

centerX = display.contentCenterX
centerY = display.contentCenterY

local widget = require("widget")

local pulsante
local numeroClick = 0

Nella prima parte dichiariamo centerX e centerY come visto nella seconda lezione. Quindi, includiamo la libreria widget, che useremo in seguito per creare il nostro pulsante. Nell’ultima parte di questo spezzone di codice dichiariamo la variabile vuota che conterrà il nostro pulsante e una variabile che contiene il numero di volte che l’abbiamo cliccato (la inizializziamo a 0, perché non l’abbiamo mai cliccato finora!).

local function pulsanteCliccato( event )
  if ( "ended" == event.phase ) then
    numeroClick = numeroClick + 1
    pulsante:setLabel(numeroClick)
  end
end

Stiamo creando una funzione, che verrà eseguita una volta cliccato il pulsante. L’unico parametro della funzione è l’evento, ovvero, in questo caso, il click del nostro pulsante. Se il click è stato effettivamente portato a termine (phase == ended), il valore della variabile numeroClick viene incrementato di 1. Il numero di click corrente viene impostato come testo del pulsante. Come già visto nella lezione precedente, i due punti ci consentono di richiamare una funzione interna ad un oggetto, per cui setLabel è una funzione del nostro pulsante.

pulsante = widget.newButton
{
  width = 280,
  height = 40,
  defaultFile = "gray_button.png",
  overFile = "gray_button_over.png",
  label = "Il primo pulsante",
  labelColor = { default={ 1, 1, 1 }, over={ 1, 1, 1 } },
  onEvent = pulsanteCliccato
}

Adesso, utilizzando la funzione newButton contenuta in widget creiamo effettivamente il nostro pulsante. Impostiamo le sue proprietà, in ordine: lunghezza, altezza, immagine di sfondo, immagine quando lo stiamo cliccando, il colore del testo, l’evento da propagare al momento del click. Come potete vedere, il colore del testo è in formato RGB (vedi lezione 2), mentre l’evento propagato è il pulsanteCliccato che abbiamo creato poco fa. Potete scaricare qui i due file immagine che ho utilizzato in questo esempio: immagine 1immagine 2.

Come ultima cosa, modifichiamo la posizione del pulsante sullo schermo, centrandolo:

pulsante.x = centerX
pulsante.y = centerY

Ecco il risultato finale:

Schermata 2015-01-25 alle 22.14.08

A voi il codice per intero:

-----------------------------------------------------------------------------------------
--
-- main.lua
--
-----------------------------------------------------------------------------------------

-- Daniele Molinari - Copyright 2015

centerX = display.contentCenterX
centerY = display.contentCenterY

local widget = require("widget")

local pulsante
local numeroClick = 0

local function pulsanteCliccato( event )
  if ( "ended" == event.phase ) then
    numeroClick = numeroClick + 1
    pulsante:setLabel(numeroClick)
  end
end

pulsante = widget.newButton
{
  width = 280,
  height = 40,
  defaultFile = "gray_button.png",
  overFile = "gray_button_over.png",
  label = "Il primo pulsante",
  labelColor = { default={ 1, 1, 1 }, over={ 1, 1, 1 } },
  onEvent = pulsanteCliccato
}

pulsante.x = centerX
pulsante.y = centerY

Icon-xxxhdpi

Microsoft Hololens: il nuovo Personal Computer

Più mi documento su ciò che Microsoft ha presentato Mercoledì 21 (video in fondo all’articolo), e più non posso fare a meno di esserne entusiasmato. Nel post precedente vi ho parlato delle meraviglie di Windows 10 (o Windows Halo, come preferisco definirlo). Ma il vero pezzo forte di Microsoft è il progetto Hololens.

Cos’è Hololens? Si tratta di un nuovo sistema a realtà aumentata. Con i Google Glass abbiamo visto come gli occhiali possano diventare uno schermo sovrapposto alla visione esteriore dell’utente, permettendo l’interazione col mondo digitale senza staccarsi dal mondo reale. Hololens promette ologrammi tridimensionali, collocati nell’ambiente in cui si trova l’utente basandosi sia su una scansione ambientale (sul modello del Kinect), sia sugli input dell’utente.

Non nascondiamocelo: i Google Glass sono stati un fallimento. Considerate però una cosa: mentre Google ha lavorato pubblicamente a centinaia di progetti negli ultimi anni, alcuni dei quali si sono rivelati più validi di altri, Microsft ha fatto, in concreto, poco e niente. Eppure Microsoft dispone del più grande patrimonio di investimento di tutte le altre grandi aziende informatiche. Salta fuori, infatti, che buona parte degli sforzi degli ultimi anni sono stati concentrati sul progetto Hololens. Microsoft lo ha definito una rivoluzione: « This is the next generation of computing. This is the next PC. » Hololens non è stato presentato come un progetto per il futuro, ma come un qualcosa che già funziona, e che sarà sul mercato nel timeframe di Windows 10.

Pensateci un momento, fino a dieci anni fa nessuno di voi aveva mai avuto fra le mani uno smartphone. Android è stato introdotto solo nel 2008, nella sua versione 1.0. Facebook è nato nel 2004. Eppure sono tutte cose che hanno cambiato radicalmente il nostro modo di vivere. La spinta allo sviluppo tecnologico che si è propagata esponenzialmente per tutto il ‘900 non si è fermata, anzi: stiamo per lanciarci in un futuro in cui l’interazione digitale diventerà tanto avanzata da fondersi con quella reale.

Quali saranno gli sviluppi tecnologici dei prossimi 10, 20 anni? Realtà aumentata, con Google Glass e Microsoft Hololens come progetti di esplorazione; realtà virtuale immersiva, con Oculus Rift; stampa 3D ed energie rinnovabili.

Pensateci, ecco come potrebbe essere la vostra vita fra qualche anno: volete comprarvi qualcosa, lo visualizzate in casa grazie a Hololens (o qualcosa di simile), vi piace, acquistate il modello per pochi centesimi e lo stampate con la vostra stampante 3D. Nessun limite ai processi produttivi. Il tutto nella maniera più ecologica possibile. La vostra giornata vi sembra noiosa? Indossate Oculus VR e andate ad ammazzare draghi nel mondo di Skyrim, col vostro martello nanico!

Non so voi, ma tutto ciò per me è davvero esaltante.

La nuova Microsoft: Windows Halo

Le ultime notizie circa il prossimo sistema operativo della Microsoft sono veramente interessanti. Per una volta, grazie alla sagacia del nuovo CEO Satya Nadella, Microsoft sta facendo bella figura con Windows, persino fra i critici più sfegatati. Cosa promette il nuovo sistema Microsoft? Maggiore integrazione fra i dispositivi, Office disponibile ovunque, maggiore integrazione con Xbox Live, assistente vocale Cortana migliorato e disponibile in tutte le lingue, nuovo browser Web Spartan.

Vi sembra una barzelletta o una notizia scherzo? Beh, non lo è. Le novità Microsoft hanno effettivamente nomi che richiamano esplicitamente alla saga di videogiochi Halo, prodotta da Microsoft stessa, che si appresta ad essere il nuovo volto dell’azienda. Non che questo mi dispiaccia, come fan della saga, anche se non proprio sfegatato.

Innanzitutto, trovo molto azzeccata la scelta di accantonare una volta per tutte Internet Explorer. La versione 11 è diventata, a mio parere, veramente ottima, ma la cattiva fama accumulatasi nel tempo sarebbe sparita effettivamente solo eliminandolo radicalmente come prodotto. Spartan è, invece, un nome e un progetto: promette di essere finalmente ciò che Internet Explorer non è stato, e di muovere guerra ai browser più utilizzati, tra cui Chrome e Firefox. L’unica pecca è l’ostinazione di Microsoft nell’integrare Bing, che non può competere con Google, e rappresenta un più che evidente fallimento.

Cortana, se ben giostrata, potrebbe costituire la punta dell’iceberg. Ciò che promette è offrire una esperienza di assistenza vocale meno fredda rispetto ai concorrenti, partecipando più attivamente al dialogo. Certo, non stiamo parlando del Jarvis di Iron Man, ma potrebbe rappresentare un enorme passo in avanti.

Windows 10 sarà inoltre il primo sistema a poter essere installato ovunque. Avere un sistema monopolistico su cellulari, tablet, PC, TV e console non sarebbe conveniente solo per Microsoft. Una tale integrazione dovrebbe permettere, infatti, di condividere contenuti nella maniera più semplice di sempre, costruendo una rete incentrata sull’account Microsoft (ex. Windows Live Id). Si, avete capito bene, console. Anche Xbox One si avvicinerà a Windows 10, anche se non sappiamo di preciso in quale misura (quantomeno nell’interfaccia grafica). L’integrazione dell’Xbox con Windows permetterà di giocare a giochi in esecuzione su un dispositivo (Windows o Xbox) utilizzandone un altro (per esempio potrete giocare da su Xbox ad un gioco in esecuzione sul PC e viceversa. Qualora tale modalità di gioco non dovesse avvenire solo in rete locale (come già avviene per Nvidia Shield), ma anche in remoto, Microsoft completerebbe la sua rivoluzione e sbancherebbe il mercato di nuovo.

In virtù di quanto detto, mi chiedo come mai Microsoft non abbia voluto chiamare il suo sistema Windows Halo, piuttosto che Windows 10, dato che comunque non rispetta la corretta numerazione delle versioni (passiamo da 8.1 a 10). Voi che ne pensate?

Corona SDK – Le basi – Lezione 2: Hello World

Nella lezione 1 abbiamo visto come installare Corona SDK su PC o Mac. In questa lezione realizzeremo la prima app compiuta, il cui unico scopo sarà mostrare a video la frase “Hello, World”, con un sfondo carino.

Innanzitutto apriamo Corona Simulator e creiamo un nuovo progetto, che chiameremo HelloWorld, scegliendo la cartella in cui salvarlo. Apriamo quindi la cartella contenente i file appena creati (per farlo potete cliccare su File -> Show Project Files mentre il progetto è aperto in Corona). Come potete notare, la cartella HelloWorld contiene diversi file: main.lua, config.lua, build.settings e i diversi formati di icone che servono per la nostra applicazione.

Consideriamo per adesso solo il file main.lua, aprendolo nell’editor (quello che avete scelto – vedi lezione 1).

-----------------------------------------------------------------------------------------
--
-- main.lua
--
-----------------------------------------------------------------------------------------

-- Your code here

Tutte queste righe che vedete sono commenti al codice. Tutto ciò che si trova dopo i doppi trattini — è da considerarsi commento. Iniziamo ora a scrivere del codice:

centerX = display.contentCenterX
centerY = display.contentCenterY
width = display.contentWidth

In Corona, le proprietà qui sopra sono proprietà del display, e per semplificare l’accesso a tali proprietà ne abbiamo salvato il valore in delle variabili, chiamate rispettivamente centerX, centerY e width. centerX si riferisce al centro orizzontale dello schermo, centerY al centro verticale dello schermo, width alla sua lunghezza (schermo del dispositivo su cui verrà eseguita l’app).

Creiamo la nostra scritta Hello, World!:

local testo = display.newText( "Hello, World!", centerX, width / 4, native.systemFont, 42 )
testo:setFillColor( 1, 20/255, 20/255 )

La prima istruzione utilizza una metodo dell’oggetto display chiamato newText. I parametri passati sono la stringa da stampare a video, l’origine dell’oggetto sullo schermo (x = centerX, y = width / 4), il font da utilizzare (predefinito del sistema), e l’altezza in pixel del font. Le coordinate x e y si riferiscono al centro dell’oggetto testo
La seconda riga utilizza un metodo dell’oggetto testo, che ci permette di impostare il colore del testo stesso. Il formato è RGB: le quantità di rosso, verde e blu vanno rispettivamente da 0 a 255. In Corona, i valori accettati dalle funzioni in generale vanno da 0 a 1, e vanno quindi scritti come frazioni (valore scelto/valore massimo). Cercando su Google troverete molte tabelle di colori in formato RGB (esempio ->).

Il nostro HelloWorld e completo e potremmo compilare! Ma, ehi! Non volete aggiungerci una immagine di sfondo? Io userò questa, scaricatela pure!

local sfondo = display.newImage( "background.jpg", centerX, centerY )

Il codice di newImage è molto simile a quello di newText: la stringa è il filename dell’immagine relativo alla cartella del progetto, centerX e centerY sono le origini dell’oggetto sullo schermo.

Salvate il file main.lua.

Tornando a Corona Simulator e riaprendo il progetto (qualora sia stato chiuso), troveremo questo risultato.

Schermata 2015-01-23 alle 16.06.31

 

Ecco tutto il codice di main.lua:

-----------------------------------------------------------------------------------------
--
-- main.lua
--
-----------------------------------------------------------------------------------------

-- Daniele Molinari - Copyright 2015

centerX = display.contentCenterX
centerY = display.contentCenterY
width = display.contentWidth

local sfondo = display.newImage( "background.jpg", centerX, centerY )

local testo = display.newText( "Hello, World!", centerX, width / 4, native.systemFont, 42 )
testo:setFillColor( 1, 20/255, 20/255 )

Alla prossima lezione!

Icon-xxxhdpi