Vanilla meta-interpreter prolog

Vanilla meta-interpreter in prolog is structured in this way.

solve(true) :- !.
solve( (A,B) ) :- !, solve(A), solve(B).
solve(A) :- clause(A,B), solve(B).

This is the implementation of the left-most goal selection.
For the right-most we need to apply solve(B) first and then solve(A).

solve(true) :- !.
solve( (A,B) ) :- !, solve(B), solve(A).
solve(A) :- clause(A,B), solve(B).

Prolog is able to prove something, but also we can compute the profundity of the path.
It is important because we can find the optimal path to reach the solution.

solve(true, 0) :- !.
solve( (A,B), S ) :- !, solve(A,SA), solve(B,SB), S is SA + SB.
solve(A,S) :- clause(A,B), solve(B,SB), S is SB.

If we wanted to define meta-interpreter solve(Goal,CF) that is true if Goal can be proved with certainty CF.

Starting from a set of rules:

rule(x, (y,z), 10).
rule(y, true, 100).
rule(z, true, 50).

solve(true, 100) :- !.
solve( (A,B), CF ) :- !, solve(A,CFA), solve(B, CFB), min(CFA,CFB,CF).
solve(A,CF) :- rule(A, B, CFR), solve(B,CFB), CF is ((CFR*CFB)/100).

min(A,B,B) :- A>=B, !.
min(A,B,A).

 

Some prolog exercises

  • Everybody who has a child is happy.
    • We need the predicates happy/1, parent/2, child/1.
      • happy(X) :- parent(X, Y), child(Y).
  • For all X, if X has a child who has a sister then X has two children.
    • We need the predicates child/1, sisterOf/2 (symmetric predicate), hastwochildren/1.
      • hastwochildren(X) :- parent(X,Y), sisterOf(Y,Z).
    • As an alternative:
      • hastwochildren(X) :- parent(X,Y), parent(X,Z), female(Z).
  • Define the relation grandchild using the parent relation. 
    • We need the predicates grandchild/2, parent/2.
      • grandchild(X,Y) :- parent(Z,X), parent(Y,Z).
  • Define the relation aunt(X, Y)
    • We need the predicates: aunt/2, parent/2, sisterOf/2.
      • aunt(X,Y) :- parent(Z,Y), sisterOf(X,Z).
  • Define the  predecessor relation
    • We need the predicates: predecessor/2, parent/2:
      • predecessor(X,Y) :- parent(X,Y).
        predecessor(X,Y) :- parent(Z,Y), predecessor(X,Y).
    • As an alternative:
    • predecessor(X,Y) :- parent(X,Y).
      predecessor(X,Y) :- parent(X,Z), predecessor(Z,Y).

Some remarks:

The predecessor relation is defined by two clauses. This set of clauses is called procedure.

Sistemi operativi a batch semplici

I sistemi operativi a batch semplici sono caratterizzati da un insieme di programmi (job) da eseguire in modo assolutamente sequenziale.


Ogni job era caratterizzato da:

  • Job begin 
  • $compile
  • $load (caricamento in memoria centrale)
  • $run (esecuzione da parte della CPU)
  • Job end

Caratteristiche:

  • I sistemi a batch semplici (chiamati anche monitor) avevano il compito di trasferire il controllo da un job (appena terminato) all’altro.
  • In ogni istante in memoria era caricato al più un solo job, e il sistema operativo (monitor).

Svantaggi:

  • Assenza di interazione tra utente e job
  • Scarsa efficienza: durante l’attesa di un evento (per esempio I/O) la CPU rimane inutilizzata, in quanto si può procedere con il prossimo job solo quando quello precedente termina la propria esecuzione
  • Lentezza I/O

 

Storia dei sistemi operativi [Introduzione]

I primi calcolatori (prima generazione) (Anni ’50) erano provvisti di valvole termoioniche, in particolare di diodi, e avevano come prerogativa il fatto di poter essere programmati attraverso il linguaggio macchina. Il sistema operativo era assente, pertanto  era l’uomo a gestire direttamente la macchina, attraverso un controllo manuale.

I calcolatori della seconda generazione (Anni ’55-’65) presentavano un’architettura basata su transistor, pertanto l’ingombro, rispetto alle valvole termoioniche diminuisce. Erano programmabili attraverso un linguaggio di alto livello, il primo fu Fortran. Per questo scopo veniva utilizzata una macchina da scrivere evoluta, attraverso la quale le istruzioni venivano “scritte” su delle schede, perforandole. Ogni istruzione era rappresentata su una scheda perforata, dunque un programma  (job) era costituito da un insieme di schede.

I programmi iniziavano ad essere aggregati in lotti, i batch. Questi ultimi erano insiemi di item, di job…pacchi di schede perforate, contenenti il codice del programma.

Da ciò nasceva l’esigenza di sviluppare i primi sistemi operativi,  chiamati monitor, e risiedevano nella memoria del computer. Si trattava di sistemi a batch semplici, che eseguivano i programmi con assoluta sequenzialità. Il loro compito era quello di passare da un job ad un altro. Il controllo poteva essere passato al job successivo solo se quello precedente aveva terminato la propria esecuzione.

C’era totale assenza di interazione tra utente e macchina e inoltre il sistema presentava poca efficienza in quanto durante l’I/O di un programma la CPU rimaneva totalmente inattiva.

L’importanza dei driver

driver sono dei moduli software che permettono al sistema operativo di poter dialogare con i vari dispositivi e periferiche.

Ogni periferica è non è direttamente collegata alla CPU per mezzo del bus di sistema, ma ha bisogno di un controller per interfacciarsi con il processore.

Nel controller sono presenti dei registri speciali, tra cui i registri di controllo nei quali il processore inserisce dei bit, i bit di comando, attraverso cui impartisce dei comandi alla periferica.

Ogni periferica ha il suo linguaggio comandi, pertanto non esiste uno standard dei comandi.

Per questo motivo, siccome un sistema operativo non può conoscere i comandi di tutti i dispositivi è necessario installare questi piccoli programmi, che permettono di interpretare e tradurre le richieste del sistema operativo ad alto livello in quelle a basso livello delle periferiche.

Linguaggio di programmazione Java

Risultato immagini per java

Java è un linguaggio di programmazione ad alto livello, nato più di 20 anni fa.  Attraverso esso si superano i limiti del linguaggio imperativo C diffusissimo a quei tempi, introducendo il motto : “Everything is an object “, ossia: tutto è un oggetto. Pertanto, nasce la programmazione ad oggetti e ci si inizia a spingere verso l’universo multi-paradigma, con diversi stili di programmazione. Infatti Java si evolve verso la programmazione funzionale e concorrente.

Tale linguaggio è riuscito ad astrarre dalla macchina e a spingersi verso una programmazione più astratta e compatibile in ogni dispositivo.

Uno degli scopi principali è quello di creare software compatibili su ogni computer, smartphone, iPhone,… in modo tale da non riscrivere codice per le diverse piattaforme.

Pertanto Java fa utilizzo di una macchina virtuale di esecuzione.  Viene compilato il codice sorgente nel linguaggio della macchina virtuale che può essere installata su i vari dispositivi. Dunque, lo stesso codice sorgente sarà eseguito sia su Windows, Mac, Linux,…, comportando un gran risparmio di tempo.

Emulare le App Android su PC gratuitamente

BlueStacks App Player

Trasforma il PC in uno Smartphone

emulare le App Android

Per emulare le App Android su PC è necessario installare BlueStacks App Player. Questa applicazione permette di riprodurre il sistema Android su PC in modo gratuito. 

emulare le App Android emulare le App Android

Scarica da qui: https://www.bluestacks.com/download.html

Guarda qui come fare: “Emulare sistema Android su PC

 

Requisiti Sistema BlueStacks

 

Come proteggere i propri file

Vi è mai capitato di voler nascondere alcuni file da occhi indesiderati? Magari avete provato migliaia di software che comunque rendono ancora visibile il file che può essere eliminato da chiunque. Ho la soluzione che fa al caso vostro.

Tutto ciò di cui avrete bisogno è già integrato nel computer. No… non dovete installare nessun programma o applicazione di alcun tipo.

Vediamo come si fa:

La metodologia che vi sto per illustrare si basa non sull’applicare una password di protezione al file, ma sul nasconderlo.

  1. Apriamo il prompt dei comandi: basta recarsi nel menù start (in basso a sinistra) e scrivere “cmd” o “prompt”.
  2. Breve dritta sui comandi dos da sapere: “dir” -> per visualizzare l’elenco di file, cartelle e collegamenti presenti nella cartella. “cd” -> per spostarsi da una cartella all’altra, o meglio, da una cartella ad una sottocartella.”cd..”-> per tornare indietro da una sottocartella alla cartella (in cui è contenuta la sottocartella). “attrib”-> per cambiare gli attributi di un file o una cartella.
  3. Indentifichiamo la posizione del file o della cartella da nascondere: per esempio nel desktop.  Una volta aperto il prompt, digitiamo “cd desktop”.
  4. Nascondiamo il file o la cartella: digitiamo nel caso di un file “attrib +h nome_file.estensione_file”  o “attrib +h nome_cartella” nel caso di una cartella. Il “+h” sta a significare che cambiamo gli attributi del file “aggiungendo” la caratteristica “nascosto”, da “hide”.
  5. Fatto! 

Per chi voglia semplificare basta scrivere nel cmd : attrib +h  percorso_file 

 

Come bloccare una cartella?

Con questo metodo si può bloccare la cartella senza fare uso di programmi o password.

  1. Crea la cartella
  2. Apri il prompt dei comandi: Dallo Start, cerca “cmd” o “prompt”.
  3. Digita: ” cacls percorso_della_cartella /E /P everyone:n “
  4. L’accesso alla cartella è bloccato
  5. Sbloccare la cartella: digitare ” cacls percorso_della _cartella /E /P everyone:f “

N.B: Attenti a non bloccare cartelle “vitali” per il sistema operativo, altrimenti il pc non funzionerà più

Come creare una cartella senza nome

Avete mai provato a creare una cartella senza nome? Se non ci siete riusciti, ecco a voi la soluzione:

  1. Crea una nuova cartella
  2. Rinominala: bisogna premere una combinazione di tasti: “Alt + 255” (Tenendo premuto Alt e contemporaneamente digitare 255) o “Alt + 0160”
  3. Premi “Invio”:  oppure clicca in un punto qualsiasi del desktop una sola volta
  4. Fatto!!