Android-x86

Android-x86 è un progetto non ufficiale che ha come obiettivo la realizzazione di un porting del sistema operativo mobile Android che sia capace di essere eseguito su piattaforme x86 e quindi di essere utilizzato sulla maggior parte dei PC compresi le applicazioni di virtualizzazione.

L'ultima versione stabile è la 4.4-r1 del branch che Google ha soprannominato "KitKat". Questa versione è la prima a implementare drivers OpenGL 2.0 e perciò consente di giocare a giochi che necessitano grafica 3D usando interamente tutte le capabilità del nostro chip grafico. Gli sviluppatori però non hanno incluso nel kernel il supporto per i chip PowerVR.

Il progetto è interamente open-source e porta tutta la tecnologia di casa Google su praticamente ogni computer che monta una CPU Intel o AMD. Il nostro team lo ha testato sia usando una flash usb sia all' interno di Virtualbox, funzionando quasi del tutto tranne per un crash della applicazione Gallery riscontrato su Virtualbox.

Sito ufficiale: http://www.android-x86.org/

 

 

PARADIGMA AD OGGETTI

La programmazione tradizionale si è sempre basata sull’utilizzo di strutture dati e su funzioni e procedure. Questo metodo di sviluppo del software viene detto funzionale, con esso si organizza un intero programma in moduli che raccolgono gruppi di funzioni. Ogni funzione accede ad uno o più gruppi di dati. I metodi di sviluppo funzionale hanno pero’ notevoli debolezze:

• A causa deglistretti legami tra le funzioni e i dati, si arriva ad un punto in cui ogni modifica software provoca degli effetti collaterali su altri moduli con enormi difficolta di debug della applicazione.
  

• Difficolta’ di riutilizzo del software. Ogni volta che si vuole riciclare una funzione bisogna apportare delle modifiche strutturali per adeguarla alla nuova applicazione.
  

La programmazione orientata agli oggetti è un modo alternativo di scomposizione di un progetto software: in essa l’unità elementare di scomposizione non è più l’operazione ma l'oggetto, inteso come modello di un’entità reale.
Questo approccio porta ad un modo nuovo di concepire un programma: il software è ora costituito da un insieme di entità interagenti, ciascuna provvista di una struttura dati e dell’insieme di operazioni che l’oggetto è in grado di effettuare su quella struttura. Poiché ciascun oggetto incapsula i propri dati e ne difende l’accesso diretto da parte del mondo esterno, si è certi che cambiamenti del mondo esterno non influenzeranno l’oggetto o il suo comportamento.
D’altra parte per utilizzare un oggetto basta conoscere che dati esso immagazzina e che operazioni esso fornisce per operare su questi dati, senza curarsi dell’effettiva realizzazione interna dell’oggetto stesso. Questo nuovo modo di sviluppare programmi software è più vicino alla nostra realtà quotidiana. Pensiamo ad un oggetto del mondo reale, ad esempio una automobile.
Una automobile ha un insieme di caratteristiche, Inoltre essa dispone di operazioni da svolgere esclusivamente con essa, ad esempio:

• accensione.
• cambio della marcia.
• parcheggio.
  

è giusto correllare le sue caratteristiche e le suo operazioni in una sola entita’ (un solo oggetto). Inoltre la programmazione ad oggetti favorisce la programmazione di gruppo, poiché gli oggetti non possono dipendere dall’implementazione di altri oggetti, ma solo dalle loro operazioni, perciò un programmatore può sviluppare un oggetto senza preoccuparsi della struttura degli altri elementi che compongono il sistema.
La parte del programma che fa uso di un oggetto si chiama client. Un linguaggio di programmazione è definito ad oggetti quando permette di implementare tre meccanismi usando la sintassi nativa del linguaggio:

• incapsulamento
  
• ereditarietà
  
• polimorfismo
  

L'incapsulamento consiste nella separazione della cosiddetta interfaccia di una classe dalla corrispondente implementazione, in modo che i client di un oggetto di quella classe possano utilizzare la prima, ma non la seconda. L'ereditarietà permette essenzialmente di definire delle classi a partire da altre già definite. Il polimorfismo permette di scrivere un client che può servirsi di oggetti di classi diverse, ma dotati di una stessa interfaccia comune; a tempo di esecuzione, quel client attiverà comportamenti diversi senza conoscere a priori il tipo specifico dell'oggetto che gli viene passato.

STORIA

Il primo linguaggio di programmazione orientato agli oggetti fu il Simula (1967), seguito negli anni settanta da Smalltalk e da varie estensioni del Lisp. Negli anni ottanta sono state create estensioni orientate ad oggetti del linguaggio C, e di altri linguaggi. Negli anni novanta è diventato il paradigma dominante, per cui gran parte dei linguaggi di programmazione erano o nativamente orientati agli oggetti o avevano una estensione in tal senso. Linguaggi che supportano solo il paradigma di programmazione orientata agli oggetti sono Smalltalk ed Eiffel. Più spesso si incontra una realizzazione non esclusiva del paradigma di programmazione orientata agli oggetti, come in C++, Java, Delphi, Python, C#, Visual Basic .NET, Perl, PHP.

CLASSI E OGGETTI

Le classi definiscono dei tipi di dato e permettono la creazione degli oggetti secondo le caratteristiche definite nella classe stessa. Grazie alle relazioni di ereditarietà, è possibile creare nuove classi a partire da quelle esistenti, estendendole con caratteristiche aggiuntive. La classe è composta da:

• attributi (analoghi ai membri di un record) cioè delle variabili e/o costanti che definiscono le caratteristiche o proprietà degli oggetti instanziabili invocando la classe; i valori inizializzati degli attributi sono ottenuti attraverso il cosiddetto costruttore;
  
• metodi (procedure che operano sugli attributi);
  

È preferibile considerare la classe come un modello astratto istanziabile. In altri termini una classe è paragonabile al progetto di un'infrastruttura che può poi essere messa in opera/esercizio ovvero realizzata o meno con l'istanziazione dei suoi oggetti tutti con medesime caratteristiche, ovvero gli attributi, su cui opereranno i metodi o funzioni.
Un oggetto è una istanza di una classe. Esso è dotato di tutti gli attributi e i metodi definiti dalla classe, ed agisce come un fornitore di "messaggi" che il codice eseguibile del programma può attivare su richiesta. Inviare un messaggio ad un oggetto si dice, in gergo, invocare un metodo su quell'oggetto. Il metodo riceve come parametro l'oggetto su cui è stato invocato, che può essere referenziato tramite una parola-chiave o una sintassi apposita, anche se è passato come parametro implicito; per esempio, in C++, in Java, e in C# si usa la parola-chiave this , mentre in Smalltalk, in Objective-C, Python e in Ruby si usa la parola-chiave self. Dal punto di vista del calcolatore, ogni oggetto è identificato da una certa zona di memoria, nella quale sono memorizzati gli attributi, e il valore di questi ultimi determina lo stato interno dell'oggetto. Istanziare un oggetto vuol dire allocare memoria ed eventualmente inizializzarla secondo le specifiche definite dalla classe. Molti linguaggi forniscono un supporto per l'inizializzazione automatica di un oggetto, con uno o più metodi speciali, detti costruttori. Analogamente, la fine della vita di un oggetto può essere gestita con un metodo detto distruttore.