Allora, eccomi qua per spiegare un'altra semplicissima funzione, ricordo che sto partendo proprio da cose estremamente semplici per permettere a tutti di capirle e prendere confidenza con questo linguaggio  

--------------------------------------------------------------------------
HL.SafeNil(value)
--------------------------------------------------------------------------
Diciamo che anche questa funzione è abbastanza banale ma mi resta molto comoda quando devo concatenare delle variabili stringa tra loro, tuttavia se una di queste stringhe è NIL Hollywood si inalbera e da errore  

Cosa sono le stringhe?
Le stringhe sono sequenze di caratteri alfanumerici, ad esempio 'pippo' è una stringa 'gianni ha 35 anni' è un'altra stringa e così via.
Una stringa vuota è semplicemente una sequenza di caratteri vuota, ossia senza caratteri. Per inizializzare una variabile stringa si può fare come segue:
Local stringa1 = "" ;     questa è una stringa vuota
Local stringa2 = "ciao!" ; questa è un'altra stringa

Concatenare le stringhe?  :?
Certo! Concatenare due o più stringhe significa semplicemente mettere in sequenza i vari caratteri delle stringhe da unire in una singola variabile, esempio:
Local risultato = "Il mio nome è " .. "Fabio"
Come si vede per unire due o più stringhe si usa l'operatore ..

Altro esempio:
DebugPrint("Il mio nome è " .. nome)
In questo caso la variabile nome non è stata inizializzata, pertanto vale NIL e Hollywood non gradisce concatenare stringhe con variabili non inizializzate: risultato il programma si interrompe ed esce inaspettatamente.

Prima regola del programmatore:
MAI, e dico MAI permettere al proprio programma di uscire in maniera inaspettata, e soprattutto incomprensibile per l'utente finale.

La funzione che ho fatto mi aiuta moltissimo proprio in questo ultimo caso, ossia quando devo concatenare delle stringhe per le quali non ho idea di cosa conterranno e devo fare in modo che se una di queste variabili sia a NIL il programma non si interrompa.

Ecco il codice semplicissimo di questa funzione:
Function HL.SafeNil(value)
;———————————————————————————————————————————————————————————————————————————————
; Returns the string 'NIL' if <value> is Nil, otherwise returns <value> without
; modifications.
;———————————————————————————————————————————————————————————————————————————————
; INPUT
;  • value        value to check against NIL
;———————————————————————————————————————————————————————————————————————————————
; OUTPUT
;  • Result       'NIL' if <value> is Nil, otherwise <value>
;———————————————————————————————————————————————————————————————————————————————
; NOTES
; This func is useful for string concatenations where there is a risk that
; the value to concatenate can be Nil, in this case the concatenation will raise
; an error breaking the code execution.
;
; Example:
;   DebugPrint("Hello " .. b)    ; In this case if <b> is Nil an error is raised
;   DebugPrint("Hello " .. HL.SafeNil(b)) ; No errors will be raised in case <b>
;                                         ; is Nil, at least you will get the
;                                         ; output:  Hello NIL
;-------------------------------------------------------------------------------

   If HL.IsNil(value)
      Return("NIL")
   Else
      Return(value)
   EndIf
   
EndFunction
Questa funzione fa una semplicissima cosa:
Se <value> è NIL restituisce una stringa contenente la parola "NIL" altrimenti restituisce <value> senza alcuna modifica.

Un'ora di spiegazione per questa cavolata di funzione? Che ci faccio adesso?
Esempio pratico
Ho una funzione che mi stampa sulla console dei messaggi per monitorare lo svolgimento del programma:
Function stampa_messaggio(messaggio)
   DebugPrint("Messaggio ricevuto:" .. messaggio)
EndFunction

Se <messaggio> è NIL il programma si interrompe con un errore, mentre se uso:
Function stampa_messaggio(messaggio)
   DebugPrint("Messaggio ricevuto:" .. HL.SafeNil(messaggio))
EndFunction
...tutto scorre come dovrebbe senza errori imprevisti  8-)

Per concludere una piccola nota sulla concatenazione: è possibile concatenare stringhe e numeri indistintamente, al momento della concatenazione Hollywood convertirà automaticamente i numeri in stringhe, provare per credere:
Local numero = 12
DebugPrint("Concatenare stringhe con numeri -->" .. numero)

La prossima volta facciamo qualcosina di leggermente più complesso  :obscene-smokingsombrero:
A presto  :whistle:

Io posso solo darti un consiglio su quali marche preferisco, nuovi modelli di notebook vengono sfornati quasi ogni settimana e le prestazioni sono grosso modo uguali per fascia di prezzo...
Anche se attualmente ho un Acer (Aspire 5740G), che non mi dispiace affatto, sono un forte simpatizzante dei notebook Toshiba e Asus, per rapporto qualità prezzo, i Toshiba secondo me sono anche molto carini esteticamente.
Poi ognuno deve scegliere la propria macchina in base all'utilizzo che ne deve fare, probabilmente a te potrebbe bastare anche un i3 per contenere il prezzo, anche se io prenderei minimo un i5.

Qua puoi effettuare delle ricerche con differenti filtri e impostazioni per trovare proprio il notebook che fa per te  
http://it.computers.toshiba-europe.com/ ... ile3;&_3sb

Beh, i case sono bruttini... direi...

benvenuto alla NSA.
La preghiamo di stare attento a dove mette i piedi.
I nostri programmi SPZIALI sono conosciuti in tutto il mondo.
Alla sua destra può vedere uno SHTTLE e alla sua sinistra un APLLO 7. Quello che ha quel motore enorme e una capoccetta grossa come una capocchia di spillo è un APLLO VISTA...
benvenuto alla NSA.

che burlone  :lol:

Innanzi tutto una piccola introduzione:
Hollywood è un linguaggio multipiattaforma in grado di compilare per quasi tutto, da quest'ultima release il compilatore è in grado di produrre eseguibili anche per Linux perciò sono coperte tutte le principali piattaforme nonchè i nostri amati sistemi Amiga e Amiga-like, per chi vuole informazioni più dettagliate può visitare la pagina ufficiale di Hollywood:
http://www.airsoftsoftwair.com/

L'autore di questo ambiente di sviluppo (Andreas Falkenhahn) definisce la propria creatura come:

Hollywood is a multimedia-oriented programming language that can be used to create graphical applications very easily

Tuttavia io ritengo che Hollywood sia adatto a programmi di tutti i tipi, logicamente multimedia, general purpose, giochi, ecc... il core di Hollywood si basa su Lua, un linguaggio di scripting molto conosciuto ed estremamente flessibile e potente, disponibile per praticamente ogni sistema operativo.

Sviluppo regolarmente con Hollywood ormai da qualche anno, l'ho scoperto dopo aver provato a fare qualcosina con Lua, e l'ho trovato fenomenale.

Fenomenale per tre motivi principali:
1. Ha praticamente tutti i lati positivi di Lua
2. Supporta pienamente tutti i sistemi Amiga e Amiga-like
3. Crosscompila per moltissime piattaforme, e a meno che non vengano usate caratteristiche particolari di un sistema la ricompilazione non necessita di grosse modifiche del codice.

Questa tuttavia non vuole essere una recensione, ma vorrei proporre alcune librerie che ho scritto presentandole come tutorial per chi ha voglia di imparare questo linguaggio o semplicemente per chi già programma e vuole semplificarsi la vita con queste librerie.
Si presuppone una infarinatura di Basic generico

-----------------------------------------------------------------------------------------------------

Le librerie in Hollywood non sono altro che un insieme di definizioni e funzioni che possono essere utilizzate in qualsiasi progetto semplicemente "includendo" il codice della libreria nel proprio progetto.

In questo prima serie presento la più semplice delle mie librerie che ho chiamato Help Library, il nome del file in cui è definita si chiama Helpers.hws (.hws è l'estensione standard dei sorgenti di Hollywood che sta per Hollywood Script, ma è possibile chiamarli come si vuole in piena filosofia Amiga).

Per poter utilizzare queste librerie è necessario direal compilatore che deve includere questa libreria nel nostro progetto, per fare ciò dobbiamo utilizzare il comando @INCLUDE, nel nostro specifico caso, in testa al nostro sorgente dovremmo scrivere il seguente comando:
@INCLUDE "Helpers.hws"
In questo caso il compilatore cercherà la libreria nel cassetto corrente, è opportuno quindi fare attenzione al percorso dove la libreria sarà salvata.

Questa libreria contiene alcune utili funzioni di uso comune, che sono:
 • HL.IsNil()                                      Verifica se il valore passato è NIL
  • HL.ParseArgs()            Effettua il parsing degli argomenti della riga di comando
  • HL.SafeNil()             Resituisce la stringa "NIL" se il parametro passatto è NIL
  • HL.Swap()                                               Scambia fra loro due valori

Tutte le funzioni e le variabili utilizzate sono memorizzate nella tabella HL.


--------------------------------------------------------------------------
HL.IsNil(value)
--------------------------------------------------------------------------
Questa funzione verifica il parametro value e restituisce TRUE se è NIL, in caso contrario resituisce FALSE.
Ma cosa significa NIL?
NIL è un valore particolare assegnato alle variabili non inizializzate, può essere inteso anche come un non-valore, ossia come viariabili senza un valore.
Purtroppo in Hollywood non esiste un modo per verificare direttamente se una variabile è inizializzata o meno, perciò mi sono creato questa piccola funzione adatta allo scopo, ecco il codice:
Function HL.IsNil(value)
;———————————————————————————————————————————————————————————————————————————————
; Returns TRUE if <value> is NIL otherwise returns FALSE
;-------------------------------------------------------------------------------
; INPUT:
;  • value        value to check against NIL
;
; OUTPUT:
;  • result       TRUE if <value> is NIL, otherwise FALSE
;-------------------------------------------------------------------------------
   
   If GetType(value) = #NIL Then Return(True) Else Return(False)
   
EndFunction

Se si tolgono i commenti rimarrà una sola riga di codice:
  If GetType(value) = #NIL Then Return(True) Else Return(False)

Come si può intuire la chiave sta nel comando GetType() con il quale è possibile risalire al tipo di variabile che stiamo analizzando, per le variabili non inizializzate questo comando restituisce #NIL che è una costante particolare di Hollywood che ci da proprio l'indicazione che cerchiamo.

Gli altri tipi di variabile che GetType() può restituire sono:
#NUMBER per le variabili numeriche
#STRING per le variabili di testo
#TABLE per le tabelle
#FUNCTION per le funzioni
#NIL per le variabili non inizializzate
#USERDATA, #LIGHTUSERDATA e #THREAD in altri casi non ancora documentati nel manuale ufficiale

In attachment c'è la libreria completa, nei prossimi post spiegherò le altre funzioni. Se avete domande non fate i timidi  :greetings-cya:

Più o meno è come quando leggi un libro e poi vedi il film... 90 su 100 rimani con l'amaro in bocca

Ciao samo!

Interessante tradizione...