English (UK)

A venirci incontro è un interessante tutorial di Nathan A. Good presente sul developerWorks di IBM: Build extensions for Eclipse one snippet at a time.

Considerato che le funzionalità dei plug-in da scrivere sono algoritmi che dipendono esclusivamente dallo sviluppatore e dagli scopi da raggiungere, indipendentemente dalla piattaforma da utilizzare, l'unica parte che ci interessa realmente è relativa alla presentazione vera e propria dei nostri dati, insomma le interfacce.

Il core di Eclipse è strutturato veramente bene in un'ottica orientata oggetti, dato che abbiamo una grande ed ordinata gerarchia di classi: tramite file XML dobbiamo indicare al core quali interfacce (intese nello spirito dell'OOP) utilizzare. Saremo noi poi a decidere se implementarle da zero, estendendo una classe astratta o utilizzando direttamente una classe ad hoc tra quelle messe a disposizione.

Esistono classi per gliscopi più disparati: dalle azioni dei pulsanti, alle voci dei menu contestuali, alle viste della GUI, agli editor testuali e così via. Sebbene sarebbe tutto, grazie sia ai nomi che alla documentazione, molto intuitivo, un tutorial risulta utile in quanto non è semplicissimo sapere quale classe bisogna utilizzare per i propri scopi, visto l'enorme labirinto di funzioni messe a disposizione che, in questo caso, funge da lato oscuro della medaglia.

Se non si ha la voglia di comprare un testo a riguardo, tenuto conto che non c'è una grande scelta, o non si ha tempo di leggerlo, il tutorial summenzionato cade a proposito. Esso copre, infatti, in modo abbastanza dettagliato i passi necessari per utilizzare interfacce e classi del core di Eclipse per creare plugin o estendere funzionalità, trattando interessanti topic come viste, azioni, preferenze, wizard e così via.

Il tutorial è scritto per Eclipse 3.2 e presuppone una certa conoscenza della programmazione, ma non presenta nulla di assolutamente difficile. Chiaramente, riprendendo quanto detto nel precedente articolo riguardo le varie distribuzioni basate su Eclipse, c'è da ricordare che essendo scritto per la versione 3.2 del core, il tutorial può essere eseguito su tutte le distribuzioni basate su questa versione, incluso IBM Rational Application Developer V7.

McNeel Rhinoceros 4.0 oltre ad essere quell'ottimo prodotto di modellazione che è, permette di integrare se stesso con funzioni aggiuntive create a parte per mezzo di plug-ins scritte in .NET.
Per creare il proprio plug-in innanzitutto bisogna preparare il corretto ambiente di sviluppo.
Teniamo conto che, escludendo Windows XP e Rhinoceros 4.0, tutto il restante software è gratuito.

Partiamo da un sistema Ms Windows XP SP2
Installiamo Windows Installer 3.1
Installiamo McNeel Rhinoceros 4.0
Con questo abbiamo il pacchetto di modellazione correttamente installato.

Proseguiamo con l'ambiente di sviluppo. Installiamo:
.NET Framework 2.0
.NET Framework 2.0 Language Pack (italian)
Ms Visual Basic 2005 Express (oppure il pacchetto open source Sharp Develop 2.2)
Ms Office Access Runtime 2007 (solo per creare file .mdb di partenza da ODBC se servono)
Rhino 4 SDK

Scarichiamo dal sito www.rhino3d.com il file Rhino4DotNetWizards.zip
Dal file copiare RMA.VisualStudioWizards.dll in C:\WINDOWS\assembly
ed eseguire Rhino4DotNetWizards.vsi
Copiare Rhino_DOTNET.xml nella cartella di rhino4.exe per avere una guida dei comandi a disposizione.

L'ambiente di sviluppo è pronto.

Il primo ambiente di sviluppo che prendiamo in esame non può che essere Eclipse e il suo PDE (Plugin Development Environment). Come dice anche il nome, Eclipse stesso non è altro che un ambiente per lo sviluppo di plug-in per la propria piattaforma; l'unione poi del framework di base con determinati plug-in fa sì che si possa avere l'ambiente di sviluppo desiderato.

È per questo che esistono varie distribuzioni ufficiali di Eclipse sul suo sito: quella per scrivere applicazioni Java, quella per applicazioni Web con Java, quella per applicazioni C/C++ e così via; si tratta dello stesso core su cui sono connessi plug-in differenti in base agli scopi da raggiungere.

Alla base di questo core esistono poi editor come IBM Rational Application Developer: nello specifico si tratta del core di Eclipse (più alcuni dei plug-in della distribuzione base) cui IBM ha agganciato dei plug-in proprietari e commerciali di propria produzione in una distribuzione esclusivamente commerciale. Quindi sommariamente, quando si usa ad esempio la distribuzione base di Eclipse, non si sta facendo altro che utilizzare il core più vari plug-in necessari, ai quali si possono aggiungere altri plug-in per estendere le funzionalità.

Sta allo sviluppatore decidere se il plug-in che sta sviluppando è pensato per essere integrato in una distribuzione esistente o in una distribuzione ad hoc; è così che nascono e crescono progetti come PHPEclipse — per la scrittura di codice PHP con Eclipse — o SBeaVeR, per la scrittura di vocabolari e regole di business secondo lo standard SBVR di OMG.

Un'altra cosa fondamentale è che Eclipse, dalla versione 3.0, è compatibile con l'OSGi framework, implementandone le specifiche e quindi aumentando la portabilità grazie a questo nuovo modello basato sui componenti.

Per uno sviluppatore Java, Eclipse è senza dubbio uno dei migiori ambienti di sviluppo. Ma questo ambiente sta crescendo sempre più e nasconde molte doti nascoste anche al di fuori di java...

Riporto pari pari, quanto scritto su programmazione.it da Pierpaolo Cira.
 
All'inizio erano all'interno di schede di cartoncino perforate, poi di circuiti non riscrivibili, poi iniziarono ad essere presenti in memorie di tipo magnetico sempre più piccole, capaci e veloci: parliamo dei software e di come, in meno di un secolo, il loro modo di presentarsi all'utente finale sia decisamente cambiato con un'accelerazione a carattere esponenziale.

Ma, oltre all’aspetto con cui i software si presentano, è cambiato anche il modo con cui essi vengono prodotti: dalla macchina perforatrice si è passati a poter inserire i dati da tastiera e, anziché sotto forma di buchi (o di 0 e 1), le istruzioni vengono codificate prima in linguaggio Assembly e poi nei primi linguaggi compilati, sempre più comodi da interpretare e rivedere da parte dei programmatori.

Insieme all'evoluzione dei linguaggi, c'è stata una corrispondente crescita dei metodi per la progettazione e l'ingegnerizzazione del software, ma ancora più importanti potrebbero essere, per alcuni, gli strumenti per la scrittura del codice: gli ambienti integrati di sviluppo o, meno formalmente, gli IDE.

Mi sono permesso di dire che per alcuni lo strumento di creazione del software possa essere più importante della progettazione stessa, visti i sempre maggiori consensi per metodologie di sviluppo agile come l'Extreme programming e considerate anche le notevoli feature messe a disposizione da IDE come Visual Studio, che tendono a nascondere allo sviluppatore gran parte della logica e delle funzioni di basso livello in modo da aumentare la produttività a scapito di codice bacato, che potrebbe scrivere l'utente e che, invece, viene direttamente scritto dall'IDE stesso.

Senza entrare nel dettaglio dei pro e dei contro di questa affermazione, è stupefacente pensare come dai primi IDE creati meno di cinquant'anni fa, che permettevano esclusivamente di scrivere codice, si è passati agli abbandonati, ma storici compilatori con interfaccia a caratteri della Borland; si è poi giunti agli attuali strumenti di sviluppo che — oltre a contenere disparati editor per il codice sorgente dalle illimitate funzioni atte a facilitare lo sviluppatore — contengono compilatori, interpreti, debugger e spesso vengono snobbati se non sono di tipo RAD.

Una tra le ultime interessanti frontiere di questi ambienti di sviluppo è che essi sono progettati per fornire agli sviluppatori la possibilità di estenderli dall'interno: un ecosistema in cui, tramite un IDE, è possibile sviluppare funzionalità per l'IDE stesso e distribuirle sotto forma di plug-in, in modo che altri utenti dello stesso ambiente possano utilizzare le nuove funzioni.

Tratto da Wikipedia, l'enciclopedia libera.

La programmazione in Java è una specializzazione della programmazione con linguaggi orientati agli oggetti.

Il linguaggio Java è un linguaggio orientato agli oggetti con una sintassi simile al linguaggio C e al linguaggio C++. Allo sviluppatore già esperto di programmazione OO, alcuni punti dovrebbero essere evidenziati:

  • Java supporta solo la singola ereditarietà di classi, ma permette l'ereditarietà multipla di interfacce.
  • Java ha una libreria di classi molto grande (detta Java API) simile a SmallTalk, e supporta molte caratteristiche, dai contenitori di oggetti a complesse esigenze di sicurezza. 
  • Java viene eseguito attraverso una Virtual Machine 
  • L'apprendimento del linguaggio non è difficile. La vastità delle "librerie" (o più correttamente package) standard del linguaggio è tale da renderne praticamente impossibile la "padronanza"; per programmare in Java è dunque necessario avere a disposizione la documentazione delle API del linguaggio, disponibile in linea sul sito ufficiale http://java.sun.com/reference/api/index.html.

Un buon punto di partenza per imparare Java è il tutorial di Sun http://java.sun.com/docs/books/tutorial/.

Per sviluppare programmi in Java è teoricamente sufficiente un qualsiasi editor di testo; in pratica, se si vuole scrivere qualcosa di più del classico hello world, occorre un ambiente di sviluppo integrato. Esistono diversi IDE (Integrated Development Environment, ambiente di sviluppo integrato), alcuni gratuiti ed altri a pagamento.

Fra questi quello più premiato è IntelliJ IDEA vincitore fra l'altro del premio Best Java IDE 2005 rilasciato da JDJ. Si tratta di un IDE completo, molto funzionale ed in grado di garantire una padronanza completa del codice che si sta sviluppando.

Un ambiente di sviluppo per Java gratuito e soprattutto leggero è BlueJ, di chiara impostazione didattica, e disponibile per tutti i sistemi operativi al sito gratuito http://www.bluej.org/. Un altro ambiente per lo sviluppo in Java (e non solo) è Eclipse, donato alla comunità di sviluppatori da IBM e scaricabile dalla pagina http://www.eclipse.org. Eclipse è più avanzato e potente, è libero e disponibile per molti sistemi operativi; da notare che quest'ultimo è strutturato con un'architettura a plugin che permette l'aggiunta di ulteriori funzionalità semplicemente scaricando ed installando il relativo plugin.

La Sun stessa ha promosso lo sviluppo di un ambiente di sviluppo gratuito e open source chiamato NetBeans e lo mette a disposizione gratuitamente insieme a Sun Java Studio. Questi due ambienti sono scritti in Java e NetBeans è distribuito (opzionalmente) insieme alla macchina virtuale. Come entità separata, NetBeans è scaricabile da netbeans.org. Uno degli IDE commerciali più diffusi è JBuilder prodotto dalla Borland.

Tratto da Wikipedia, l'enciclopedia libera.

Fra gli argomenti che depongono spesso a favore di Java nella scelta del linguaggio di implementazione di un progetto software moderno, inoltre, si deve certamente contare la vastità delle librerie standard di cui il linguaggio è dotato, e che in particolare contribuiscono a renderlo altamente integrabile con le altre tecnologie. Alcuni esempi di funzionalità di libreria di Java sono:

  • accesso ai database tramite JDBC e ai DBMS con driver ODBC tramite il bridge JDBC-ODBC
  • manipolazione documenti XML
  • dialogo con piattaforme CORBA
  • potenti strumenti per la programmazione lato server nel contesto Web
  • supporto nativo per gran parte dei protocolli della famiglia IP, vedi ad esempio il Socket Java
  • supporto per le applicazioni multimediali, streaming audio e video

Secondo molte persone, la tecnologia Java raggiunge ragionevolmente bene tutti i suoi obiettivi. Il linguaggio comunque non è privo di incertezze. Java tende ad essere più ad alto livello di altri linguaggi simili (come il C++); questo comporta carenze in alcune caratteristiche come i tipi di dati specifici, puntatori alla memoria di basso livello e metodi di programmazione come l'overloading degli operatori.

Nonostante queste caratteristiche siano abusate frequentemente dai programmatori, esse sono anche strumenti potenti. Comunque, la tecnologia Java include Java Native Interface (JNI), un modo per chiamare codice nativo da codice Java. Con JNI è quindi possibile ugualmente usare queste caratteristiche.

Alcuni programmatori lamentano anche la mancanza dell'ereditarietà multipla, un potente mezzo di molti linguaggi orientati agli oggetti, tra cui il C++. Il linguaggio Java separa l'ereditarietà del tipo dall'implementazione, permettendo l'ereditarietà multipla dei tipi attraverso le interfacce. Questo permette di ottenere la maggior parte dei benefici dell'ereditarietà multipla evitando molti dei suoi pericoli. Inoltre, attraverso l'uso di classi concrete, classi astratte e interfacce, un programmatore ha la possibilità di scegliere un grado completo, parziale o nullo di implementazione dell'oggetto che definisce, essendo assicurata la massima flessibilità nella progettazione.

Alcune persone pensano che per particolari progetti, la programmazione orientata agli oggetti renda il lavoro più difficile. Questa particolare lamentela non è peculiare di Java, ma è rivolta a tutti i linguaggi di questo tipo. Per contro, la gran parte delle aziende che sviluppano software ha eseguito da tempo il "salto" verso questo nuovo tipo di tecnologie.

Tratto da Wikipedia, l'enciclopedia libera.

La piattaforma Java fu uno dei primi sistemi a fornire un largo supporto per l'esecuzione del codice da sorgenti remote. Un Java applet è un particolare tipo di applicazione che può essere avviata all'interno del browser dell'utente, eseguendo codice scaricato da un server web remoto. Questo codice viene eseguito in un'area (sandbox) altamente ristretta, che protegge l'utente dalla possibilità che il codice sia malevolo o abbia un comportamento non desiderato; chi pubblica il codice può applicare un certificato che usa per firmare digitalmente le applet dichiarandole "sicure", dando loro il permesso di uscire dall'area ristretta e accedere al filesystem e al network, presumibilmente con l'approvazione e sotto il controllo dell'utente. In realtà gli applet non hanno avuto molta fortuna. Infatti presuppone che il client in cui essi vengono eseguiti abbia installata la JRE (deve eseguire il codice dell'applet). Hanno avuto fortuna le applicazioni che prevedono il cosiddetto thin-client, cioè un client 'leggero' che non ha bisogno di particolari strumenti per eseguire il codice remoto (a volte è necessario solo il browser).

Rispetto alla tradizione dei linguaggi a oggetti da cui deriva (e in particolare rispetto al suo diretto progenitore, il C++), Java ha introdotto una serie di notevoli novità rispetto all'estensione della sua semantica. Fra le più significative si possono citare probabilmente la possibilità di costruire GUI (interfacce grafiche) con strumenti standard e non proprietari (per il C++ e altri linguaggi analoghi solitamente le GUI non fanno parte del linguaggio, ma sono delegate a librerie esterne), la possibilità di creare applicazioni multi-thread, ovvero che svolgono in modo concorrente molteplici attività, e il supporto per la riflessione, ovvero la capacità di un programma di agire sulla propria struttura e di utilizzare classi caricate dinamicamente dall'esterno.

Tratto da Wikipedia, l'enciclopedia libera.

La seconda caratteristica, l'indipendenza dalla piattaforma, significa che l'esecuzione di programmi scritti in Java deve avere un comportamento simile su hardware diverso. Si dovrebbe essere in grado di scrivere il programma una volta e farlo eseguire dovunque. Questo è possibile con la compilazione del codice di Java in un linguaggio intermedio bytecode, basato su istruzioni semplificate che ricalcano il linguaggio macchina. Esso viene eseguito da una macchina virtuale, cioè da un interprete: Java è quindi, in linea di massima, un linguaggio interpretato. Inoltre, vengono fornite librerie standardizzate per permettere l'accesso alle caratteristiche della macchina (come grafica e networking) in modo unificato. Il linguaggio Java include anche il supporto per i programmi con multithread, necessario per molte applicazioni che usano la rete.

La portabilità è un obiettivo tecnicamente difficile da raggiungere, e il successo di Java in questo ambito è materia di alcune controversie. Sebbene sia in effetti possibile scrivere in Java programmi che si comportano in modo consistente attraverso molte piattaforme diverse, bisogna tenere presente che questi poi dipendono dalle virtual machine, che sono programmi a sé e che hanno inevitabilmente i loro bug, diversi dall'una all'altra: per questo è nata una parodia dello slogan di Sun "Scrivi una volta, esegui dovunque" ("write once, run everywhere"), che è diventato "Scrivi una volta, fai il debug ovunque".

Le prime implementazioni del linguaggio usavano una virtual machine che intepretava il bytecode per ottenere la massima portabilità, definita Architecture Neutral. Questa soluzione si è però rivelata poco efficiente, in quanto i programmi interpretati erano molto lenti. Per questo, tutte le implementazioni recenti di macchine virtuali Java hanno incorporato un JIT compiler, cioè un compilatore interno, che al momento del lancio traduce al volo il programma bytecode Java in un normale programma nel linguaggio macchina del computer ospite. Inoltre, questa ricompilazione è dinamica, cioè la virtual machine analizza costantemente il modello di esecuzione del codice (profiling), e ottimizza ulteriormente le parti più frequentemente eseguite, mentre il programma è in esecuzione. Questi accorgimenti, a prezzo di una piccola attesa in fase di lancio del programma, permettono di avere delle applicazioni Java decisamente più veloci e leggere. Tuttavia, anche così Java resta un linguaggio meno efficiente dei linguaggi compilati come il C++, scontando il fatto di possedere degli strati di astrazione in più, e di implementare una serie di automatismi, come il garbage collector, che se da un lato fanno risparmiare tempo ed errori in fase di sviluppo dei programmi, dall'altro consumano memoria e tempo di CPU in fase di esecuzione del programma finito.

Tratto da Wikipedia, l'enciclopedia libera.

La prima caratteristica, l'orientamento agli oggetti, si riferisce a un moderno metodo di programmazione e progettazione. L'idea principale della programmazione ad oggetti consiste nel rendere il software la rappresentazione di entità reali o astratte ma ben definite (oggetti). Questi oggetti, come nella vita pratica, hanno proprietà rappresentate da valori, e qualità o meglio metodi: ciò che sanno fare questi oggetti. Si pensi ad una automobile: ha delle proprietà come il colore o il numero di porte, e dei metodi, per esempio può girare a destra o sinistra, andare avanti o indietro, accelerare, decelerare ecc. Riportando la programmazione in questi termini è facile capire come questo renda più facile la gestione di grandi progetti, migliorarne la qualità e la mantenibilità.

L'eredità in java è implementata mediante la parola chiave extends applicato dopo la dichiarazione di una classe

Una classe estende sempre una e una sola altra classe, ma può a sua volta essere estesa da un numero arbitrario di classi, se non specificato la classe estende di norma la classe Object

Questo sistema rende disponibile un modo per creare gerarchie di classi ben definite, ad esempio una classe Quadrilatero può definire alcuni comportamenti generali per tutte le figure geometriche con 4 lati, tuttavia si può presentare la necessità di aver bisogno di caratteristiche più specifiche per i nostri oggetti, quindi creiamo una classe Quadrato che estende la classe Quadrilatero da cui deriva tutti gli attributi (le variabili di istanza) e tutti i comportamenti (i metodi di istanza) relativi ad un qualunque quadrilatero, salvo poi riscrivere (overriding) quei comportamenti che sono prettamente associati ai quadrati (come ad esempio avere 4 lati uguali).

L'overriding si attua semplicemente scrivendo all'interno della classe che estende (in questo caso la classe Quadrato) il metodo che vogliamo riscrivere, utilizzando la stessa firma del relativo metodo della superclasse (deve avere lo stesso nome e gli stessi attributi, in numero e tipo)

È bene puntualizzare, quindi, che la tecnica dell'ereditarietà serve per specificare e specializzare un determinato comportamento, non viceversa. In java non è prevista l'ereditarietà multipla (una classe può avere al più una superclasse).

L'utilizzo di una interfaccia in java consente a tutti gli oggetti che implementano di unificare il loro comportamento. Ovvero l'oggetto interface in java è una semplice dichiarazione di metodi che tutte le classi che implementano l'interfaccia devono realizzare al loro interno.

Con l'implementazione dell'interfaccia la classe Quadrato deve contenere al suo interno i metodi calcolaPerimetro e calcolaArea propri che non possono essere ereditati dalla classe padre. L'utilizzo delle interfacce viene usato quando si hanno delle gerarchie di oggetti, o oggetti semplici che possiedono delle operazioni comuni (metodi), ma l'implementazione di queste sono differenti una dall'altra.


© 2017 Bruno Tessaro. My life in the web. All right reserved.