Questo articolo parla del linguaggio di programmazione Kotlin. Imparerai le ragioni dell'emergere del progetto, le capacità della lingua e vedrai diversi esempi. L'articolo è stato scritto principalmente con l'aspettativa che il lettore abbia familiarità con il linguaggio di programmazione Java, tuttavia anche chi conosce un'altra lingua potrà farsi un'idea dell'argomento. L'articolo è superficiale e non affronta le problematiche legate alla compilazione in javascript. Puoi trovare la documentazione completa sul sito ufficiale del progetto, ma proverò a parlare brevemente del linguaggio.
Informazioni sul progetto
Non molto tempo fa, JetBrains, un'azienda che crea ambienti di sviluppo, ha annunciato il suo nuovo prodotto: il linguaggio di programmazione Kotlin. Un'ondata di critiche ha colpito l'azienda: i critici hanno suggerito che l'azienda tornasse in sé e completasse il plugin per Scala, invece di sviluppare un proprio linguaggio. Agli sviluppatori Scala manca davvero un buon ambiente di sviluppo, ma i problemi degli sviluppatori di plugin sono comprensibili: Scala, che è nata grazie a ricercatori svizzeri, ha incorporato molti concetti e approcci scientifici innovativi, il che ha reso la creazione di un buon strumento di sviluppo un compito estremamente difficile . Al momento, il segmento dei moderni linguaggi tipizzati staticamente per la JVM è piccolo, quindi la decisione di creare il proprio linguaggio insieme a un ambiente di sviluppo sembra molto lungimirante. Anche se questo linguaggio non mette affatto radici nella comunità, JetBrains lo realizza principalmente per le sue esigenze. Qualsiasi programmatore Java può comprendere queste esigenze: Java come linguaggio si sta sviluppando molto lentamente, nel linguaggio non compaiono nuove funzionalità (aspettiamo funzioni di primo ordine già da diversi anni), la compatibilità con le versioni precedenti del linguaggio lo rende impossibile che molte cose utili appaiano nel prossimo futuro (ad esempio, parametrizzazione di tipo decente). Per un'azienda che sviluppa software, il linguaggio di programmazione è il principale strumento di lavoro, quindi l'efficienza e la semplicità del linguaggio sono indicatori da cui dipende non solo la facilità di sviluppo di strumenti, ma anche i costi di codifica del programmatore, ad es. essere quello di mantenere questo codice e capirlo.A proposito della lingua
La lingua è tipizzata staticamente. Ma rispetto a Java, il compilatore Kotlin aggiunge informazioni al tipo sulla possibilità che il riferimento contenga null, il che rafforza il controllo del tipo e rende l'esecuzione più sicura:Divertente foo(text:String) ( println(text.toLowerCase()) // NPE? No! ) val str:String? = null // Stringa? -- tipo nullable foo(str) //<- компилятор не пропустит такой вызов -- // тип str должен быть String, чтобы // передать его в foo
Nonostante questo approccio possa salvare il programmatore da una serie di problemi associati a NPE, per un programmatore Java all'inizio sembra non necessario: è necessario eseguire controlli o conversioni non necessari. Ma dopo un po' di tempo di programmazione in Kotlin, tornando a Java, senti che ti mancano queste informazioni sul tipo e pensi di usare le annotazioni Nullable/NotNull. A questo si riferiscono i problemi di compatibilità con le versioni precedenti con Java: queste informazioni non sono nel bytecode Java, ma per quanto ne so, questo problema è ancora in fase di risoluzione e per ora tutti i tipi provenienti da Java sono annullabili.
A proposito, riguardo alla compatibilità con le versioni precedenti: Kotlin è compilato nel bytecode JVM (i creatori del linguaggio dedicano molti sforzi al mantenimento della compatibilità), che gli consente di essere utilizzato nello stesso progetto con Java e la possibilità di utilizzare reciprocamente Java e le classi Kotlin rendono la soglia per introdurre Kotlin in un grande progetto Java esistente molto minimale. Importante a questo proposito è la possibilità di utilizzare più sviluppi Java creando un progetto interamente in Kotlin. Ad esempio, è stato quasi facile per me realizzare un piccolo progetto basato su spring-webmvc.
Diamo un'occhiata al frammento del controller:
Path(array("/notes/")) classe controller NotesController ( private autowired val notesService: NotesService? = null path(array("all")) fun all() = render("notes/notes") ( addObject(" note", notesService!!.all) ) //... )
Le peculiarità dell'uso delle annotazioni in Kotlin sono visibili: in alcuni punti non sembra così pulito come in Java (questo vale per casi speciali, ad esempio, un array di un elemento), ma le annotazioni possono essere usate come parole chiave "fatte in casa" come come autowired o controller (se si specifica un tipo di alias durante l'importazione) e in termini di funzionalità, le annotazioni sono più vicine alle classi reali.
Va notato che Spring non è stata in grado di eseguire il wrapper delle classi Kotlin per gestire le transazioni: spero che ciò sia possibile in futuro.
Il linguaggio supporta funzioni di prima classe. Ciò significa che una funzione è un tipo integrato nel linguaggio per il quale esiste una sintassi speciale. Le funzioni possono essere create localmente, passate come parametri ad altre funzioni e i riferimenti ad esse memorizzati:
Divertimento faiSomething(thing:()->Unit) ( // dichiara un parametro di tipo function // ()->Unit non accetta nulla e // non restituisce nulla di importante thing() // chiama ) doSomething() ( // e qui al volo creiamo una funzione del tipo // ()->Unit e la passiamo alla funzione doShomething // se la funzione è l'ultimo parametro puoi // spostarla fuori dalle parentesi di chiamata println("Ciao mondo") )
Se a questa estensione aggiungiamo funzioni che ci consentono di estendere una classe già esistente utilizzando un metodo che non viola l'incapsulamento della classe, ma a cui è possibile accedere come metodi di questa classe, otterremo un meccanismo abbastanza potente per estendere librerie Java standard che sono piuttosto scarse in termini di praticità. Per tradizione, aggiungiamo la possibilità di filtrare l'elenco già esistente nella libreria standard:
Divertimento
Tieni presente che le variabili non hanno tipi specificati: il compilatore Kotlin li deduce se possibile e non interferisce con la comprensibilità dell'interfaccia. In generale, il linguaggio è progettato in modo tale da evitare il più possibile a chi sta alla tastiera di digitare caratteri non necessari: una sintassi breve ma chiara con un minimo di parole chiave, nessuna necessità di punto e virgola per separare le espressioni, inferenza di tipo dove appropriato, nessuna nuova parola chiave per creare la classe: solo ciò che è necessario.
Per illustrare l'argomento delle classi e della brevità, diamo un'occhiata al seguente codice:
// la creazione delle classi bean diventa // laconica, i campi possono essere dichiarati // direttamente nella dichiarazione del costruttore class TimeLord(val name:String) // la classe potrebbe non avere affatto un corpo class TARDIS(val proprietario:TimeLord) fun main (argomenti:Array
In poche righe siamo riusciti a dichiarare due classi, creare due oggetti e stampare il nome del proprietario del TARDIS! Si può notare che la classe viene dichiarata con i parametri del suo unico possibile costruttore, che sono anche la dichiarazione delle sue proprietà. Estremamente breve, ma informativo. Sicuramente ci sarà chi condannerà l'impossibilità di dichiarare più di un costruttore, ma mi sembra che questo abbia il suo pragmatismo - dopo tutto, diversi costruttori in Java ti permettono di dichiarare parametri predefiniti, che Kotlin supporta nel linguaggio level, o converti un tipo in un altro, con cui funzionerà questa classe, e questo può già essere tranquillamente lasciato al metodo factory. Prestare attenzione alla dichiarazione delle “variabili” e dei campi. Kotlin ci obbliga a fare una scelta: val o var . Dove val dichiara un riferimento finale immutabile e var dichiara una variabile, il che aiuta a evitare l'uso diffuso di riferimenti mutabili.
Esempio
Ora siamo arrivati al punto in cui possiamo fare qualcosa di più interessante. Durante le interviste, spesso do il compito di realizzare un albero, attraversarlo e determinare alcune azioni con un elemento. Vediamo come viene implementato in Kotlin.Questo è come vorrei che fosse l'utilizzo:
Divertente main(argomenti: Array
Ora proviamo a implementarlo. Creiamo una classe di nodi dell'albero:
/** * @param valore dati del nodo */ class Node
Ora aggiungiamo una funzione per creare la parte superiore dell'albero:
/** * Crea un nodo dell'albero con valore valore e inizializza * i suoi figli con il metodo init.
( val node = Node(value) // chiama il metodo init passato nel // parametro sull'oggetto nodo node.init() return node )
In due punti del codice è stata utilizzata una costruzione come Node.()->Unit, il cui significato è che come input è previsto un tipo di funzione, che verrà eseguita come metodo di un oggetto di tipo Node. Dal corpo di questa funzione si accede ad altri metodi di questo oggetto, come il metodo Node.node(), che permette di eseguire l'inizializzazione dell'albero simile a quella descritta nell'esempio.
Invece di una conclusione
Se sei interessato alla lingua, tutte le informazioni sulla lingua possono essere trovate sul sito ufficiale del progetto, le loro fonti possono essere trovate su github e qualsiasi errore trovato può essere pubblicato nell'Issue Tracker. Ci sono ancora molti problemi, ma gli sviluppatori del linguaggio li stanno combattendo attivamente. Ora il team sta lavorando sulla versione ancora non molto stabile della pietra miliare 3, dopo la stabilizzazione, per quanto ne so, è previsto l'utilizzo del linguaggio all'interno dell'azienda JetBrains, dopodiché è già prevista la prima release.
Tag: aggiungi tag
Nel 2017 c'è stato un nuovo clamore intorno a YP (Linguaggio di programmazione) Kotlin, e in questo contesto voglio parlarvi anche di altre novità nello sviluppo di programmi per smartphone basati sul sistema operativo Android. Ma questo è il mio blog personale, e non una sorta di risorsa accademica, e quindi, prima, mi permetterò alcune divagazioni liriche laterali, rivolgendo lo sguardo al passato.
Escursione storica
La mia prima conoscenza con la programmazione di smartphone con sistema operativo Android è stata all'inizio del 2012, cioè esattamente 6 anni fa. In quei tempi lontani, Google non aveva ancora creato il suo magnifico IDE (Ambiente di sviluppo integrato, Ambiente di sviluppo integrato) Android Studio e utilizzo l'IDE Eclipse con il plug-in ADT installato (Strumenti di sviluppo Android, Strumenti di sviluppo Android). Il motivo della nostra conoscenza è stato l'acquisto del mio primo smartphone, HTC Desire HD, meno di un anno prima, all'inizio dell'estate del 2011.
Java era considerato il linguaggio di programmazione nativo per Android. Era una nuova lingua per me, quindi ho dovuto affrontare una tripla sfida: un nuovo IDE, una nuova lingua e un nuovo sistema operativo (Sistema operativo), e tutto questo allo stesso tempo. Tuttavia, in qualche modo ho imparato a scrivere programmi per Android e ho anche scritto un prodotto commerciale, per il quale ho ricevuto volentieri una ricompensa di 1000 euro.
Tuttavia, la programmazione per Android si è rivelata estremamente scomoda, di cui parlo anche periodicamente. Ecco l'imperfezione dell'IDE e il sottosviluppo delle librerie standard in direzione di Android, e loro, e i difetti di tutto questo separatamente.
Un altro anno dopo all'inizio del 2013 Ho anche iniziato a scrivere un blog speciale chiamato “Android, trucchi con le orecchie” con la caratteristica epigrafe “ I ricci piangevano, si facevano l'iniezione, ma continuavano a rosicchiare il cactus...", in cui pubblicavo periodicamente soluzioni ad alcuni problemi che ho riscontrato e pubblicavo anche alcune informazioni di base aggiuntive, come per la mia memoria.
Nel 2014È apparsa la prima versione stabile dell'IDE di Google stessa (anche se basato sull'IDE IntelliJ IDEA, scritto nella società legalmente ceca JetBrains, fondata a Praga da tre programmatori russi).
In generale, tutto è iniziato con la società russa StarSoft, che ha iniziato le sue attività subito dopo il colpo di stato dell'agosto 1991 sulla base del laboratorio di software dell'Accademia umanitaria indipendente di San Pietroburgo, e allora era composta da tre persone. Nel 1993 sono iniziati i lavori sul progetto Together (strumento di progettazione software), la cui idea è stata proposta da un tedesco proveniente dalla Germania. Nel 1995 la società è stata ribattezzata STAR SPb e ufficialmente registrata come ufficio di rappresentanza russo del gruppo STAR. Nel 1999, la società "russo-tedesca" TogetherSoft, composta da specialisti che hanno lavorato al prodotto Together, si è staccata da STAR SPb. Tra i cofondatori, come sempre, c'erano gli americani che decisero che i buoni programmatori dovevano essere portati urgentemente da San Pietroburgo in Europa, e nello stesso 1999, il top team di TogetherSoft (circa 50 persone)è andato a Praga. Tra loro c'erano i tre futuri fondatori di JetBrains. E così, nel 2000, fondarono la società JetBrains e si registrarono nello stesso luogo in cui vivevano allora, a Praga.
Il prodotto di punta di JetBrains è IntelliJ IDEA, un IDE per molti linguaggi di programmazione. Google lo ha preso come base per il suo IDE Android Studio. A proposito, anche il cofondatore di Google è russo. Se scavi un po', le radici russe sporgono ovunque... È nato a Mosca e ha vissuto lì fino all'età di 5 anni, poi la sua famiglia emigrò in America nel 1979, come era allora consuetudine tra gli ebrei. A causa dell'antisemitismo, in particolare, la presenza di quote per l'ingresso degli ebrei nelle università. Dapprima gli ebrei, come popolo, si isolano, sottolineano in ogni modo possibile la loro scelta di Dio e non nascondono la loro mentalità non sempre accettabile in regioni con una diversa religione dominante e una diversa mentalità, e poi si sorprendono del risultato . Tuttavia, questo è un altro argomento. Nonostante il suo atteggiamento, per usare un eufemismo, scettico nei confronti della sua ex patria (cos'altro puoi aspettarti da una persona cresciuta da emigranti sovietici), condivido completamente le sue opinioni, in particolare su Internet. E molte affermazioni critiche sulla Russia sono abbastanza giuste, anche se spiacevoli se ascoltate dalle labbra di uno straniero. Tuttavia mi sono distratto nuovamente...
Quindi, quando è apparso Android Studio, sono passato immediatamente ad esso come IDE potenzialmente più promettente per lo sviluppo per Android. Devo dire che all'inizio erano evidenti sia i pro che i contro rispetto a Eclipse. Tuttavia c'erano molti altri vantaggi e me ne sono innamorato fermamente.
Da dilettante, non programmo regolarmente e mi sono perso completamente l'ultimo 2017 in termini di Android. E ora ho deciso di aggiornare l'IDE e vedere quali novità sono apparse nel frattempo. E si è scoperto che lì sono apparse molte cose significative! Di seguito elencherò alcune innovazioni particolarmente notevoli che valuto molto positivamente.
Nuovo linguaggio di programmazione Kotlin
Fino a poco tempo fa, Android Studio supportava solo la programmazione in Java (Java, in precedenza più spesso detto Java. La lingua prende il nome da una marca di caffè, che, a sua volta, prende il nome da un'isola dell'Indonesia) e in C++ per il codice nativo. Il linguaggio Java non è molto antico, ma considerato il focus relativamente giovane del suo utilizzo (multipiattaforma), piuttosto anziano. È stato sviluppato dalla famosa azienda Sun Microsystems nel 1995. La lingua era originariamente chiamata Oak ("Quercia") ed è stato sviluppato per programmare dispositivi elettronici di consumo. È stato quindi rinominato Java e utilizzato per scrivere applicazioni client e software server. Successivamente apparvero altri usi.
Noto che Java funziona in tandem con un compilatore, che non produce il codice completo per la sua esecuzione nel sistema operativo. I testi originali scritti in questo linguaggio sono compilati in uno speciale bytecode, che viene eseguito su una speciale macchina virtuale, inoltre installata sul sistema, che traduce questo codice in comandi comprensibili al sistema operativo e al processore. Pertanto, i programmi scritti in questo linguaggio possono essere eseguiti su qualsiasi dispositivo su cui è installata tale macchina virtuale. E le macchine virtuali Java sono già state scritte per una varietà di architetture. Ecco come si realizzano i programmi multipiattaforma. Lo svantaggio di questo approccio è l'aumento del tempo di esecuzione dovuto ad un ulteriore livello sotto forma di macchina virtuale tra il codice e il processore. Inoltre, i programmi Java spesso vengono eseguiti più lentamente a causa delle imperfezioni di molte librerie Java, ad esempio le librerie GUI. Ma tutto questo è il prezzo per la multipiattaforma.
E proprio di recente, alla fine del 2017, è stato rilasciato Android Studio 3.0, che, insieme ai linguaggi Java e C++, ha iniziato a supportare il linguaggio Kotlin (Kotlin), che, come Java, è progettato per creare lo stesso bytecode per la stessa macchina virtuale, ma ha una sintassi diversa che consente di scrivere un codice sorgente molto più compatto. Allo stesso tempo, i file sorgente in entrambe le lingue possono essere mescolati senza restrizioni in un unico progetto, il che rende possibile trasferire gradualmente l'intero progetto su Kotlin.
La lingua è completamente fresca. Ha iniziato lo sviluppo nel 2010, è stato presentato al pubblico nel 2011, la programmazione per Android è diventata possibile nel 2012 e la versione ufficiale è stata rilasciata di recente, nel 2016. A proposito, secondo la tradizione (uguale a Java) la lingua prende il nome dall'isola. Questa volta si tratta dell'isola russa di Kotlin nel Golfo di Finlandia, su cui si trova la città di Kronstadt. E il linguaggio è stato sviluppato da programmatori di San Pietroburgo, tutti della stessa azienda JetBrains! Oh, come, un vero linguaggio di programmazione russo! [I patrioti dovrebbero sventolare le bandiere, e l'autore di questo post sta già camminando in tondo per la stanza, agitando minacciosamente il bastone...]
Ho già provato a scrivere in questa lingua per Android e posso dire con sicurezza che la lingua è abbastanza adatta. In precedenza, mi perdevo nel codice Java, perché in Android devi scrivere tutto e tutti, e ti ritrovi con fogli di codice sorgente molto lunghi. Di conseguenza, il codice sorgente è cresciuto fino a raggiungere dimensioni oscene e hanno dovuto essere suddivisi con precisione in classi, inseriti in file diversi e quindi ero già perso nei file. Kotlin utilizza la filosofia “tutto ciò che può essere generato automaticamente dovrebbe essere generato automaticamente”. Da un lato il codice diventa meno trasparente (meno, ma forse solo per principianti), ma più semplice e compatto (un grande vantaggio per tutti).
La compattezza del codice è raggiunta non solo grazie alle strutture sintattiche abbreviate, ma anche grazie alle librerie standard, il cui metodo di utilizzo è appositamente studiato per la compattezza e l'ergonomia. Un esempio di questo potrebbero essere le coroutine (o, come carta da lucido dall'inglese, coroutine). Le coroutine rappresentano un modo molto chiaro e compatto di formattare il codice che deve essere eseguito in modo asincrono dal thread principale. Non è necessario scrivere classi aggiuntive con metodi separatamente; tutto viene fatto direttamente nel codice principale, e questo è fantastico! Inoltre, le coroutine sono implementate a livello della libreria stessa e non creano thread di sistema pesanti. Sono anche chiamati fili leggeri. Pertanto, non ci sono praticamente restrizioni sul numero di essi lanciati contemporaneamente. Le coroutine sono incredibili!
Componenti architettonici per Android di Google
Si è rivelato anche molto compatto creare e utilizzare un database SQLite utilizzando la libreria Room, che è un wrapper della nota classe SQLiteOpenHelper. Per utilizzare Room è sufficiente descrivere due piccole classi che descrivono la tabella e il database e una piccola interfaccia che descrive le funzioni per interagire con questo database. In Kotlin non è necessario inserire tutto questo in file diversi. Sulla base di queste scarse informazioni, Room riprodurrà automaticamente e internamente tutte le azioni che prima dovevano essere scritte in file enormi. Miracoli!
Nelle applicazioni reali, è necessario tenere traccia delle modifiche nei dati nel database e aggiornare automaticamente le informazioni nei componenti visivi. Pertanto, il componente Room viene spesso utilizzato non da solo, ma insieme al componente LiveData della libreria android.arch.lifecycle. Questo componente è anche facile da usare. I dati che devono essere tracciati vengono trasferiti dal database alla variabile non direttamente, ma sotto forma di classe LiveData, che ha ricevuto questi dati come parametro all'interno di Room. Successivamente, nel codice principale, una riga di Kotlin imposta il loro monitoraggio e la funzione di aggiornamento della componente visiva, che viene avviata quando i dati cambiano. Tutto è elementare!
Un altro componente utile della libreria android.arch.lifecycle che risolve il problema del salvataggio dei dati delle attività durante la rotazione dello schermo è ViewModel. In precedenza, era necessario scrivere tutti i tipi di stampelle ingegnose in modo che i dati non andassero persi e i calcoli non venissero interrotti. Ora c'è una componente ufficiale per questo! Se prima abbiamo separato l'interfaccia dal codice (markup e attività), è giunto il momento di separare il codice che dovrebbe essere eseguito solo durante il ciclo di vita dell'attività (ad esempio, garantire il funzionamento dell'interfaccia utente), dal codice che deve essere eseguito al di fuori del ciclo di vita di un'attività specifica (ad esempio, ricezione, elaborazione e trasmissione di dati). In questo caso potremo leggere automaticamente il risultato della seconda parte del codice nell'attività ricreata dopo aver ruotato lo schermo.
Per implementare l'intero schema con ViewModel, è richiesto anche un minimo di azioni. Viene scritta una classe separata con codice che non deve essere interrotto (il cosiddetto view model, non so perché “model”; forse ho tradotto male) e nel codice principale, in una riga, viene chiamato il provider del modello, al quale questa classe viene passata come parametro. Il provider restituisce un oggetto della classe del modello esistente (dopo aver ruotato lo schermo), oppure crea un oggetto di questo tipo in base alla classe passata, se non esiste ancora, e lo restituisce (quando l'attività viene avviata per la prima volta). Un'attività può sempre accedere alle funzioni e alle variabili di questo oggetto.
Tutti e tre i componenti sono combinati sotto il nome ufficiale Android Architecture Components. È vero, include anche il componente LifeCycle, anch'esso situato nella libreria android.arch.lifecycle, ma viene utilizzato in stretta collaborazione con LiveData e non lo evidenzierei affatto. L'introduzione di componenti di così alto livello è un gradito passo nella giusta direzione per Google. Mi lamento da molto tempo di quante classi diverse devo estendere e collegarle tutte tra loro per far funzionare qualcosa di poco più che semplici esempi di libri di testo. E finalmente, tra le biblioteche iniziarono ad apparire i componenti corretti. Spero che questa tendenza continui.
Editor dell'interfaccia visiva
Le innovazioni che ho scoperto nella programmazione degli smartphone non finiscono qui. Fin dalla sua nascita, Android Studio ha avuto difficoltà con la stabilità e la prevedibilità dell'editor dell'interfaccia visiva, sebbene fosse più stabile rispetto a Eclipse. Anche modificando direttamente il markup xml dell'interfaccia, è stato molto difficile configurare tutti questi layout e altri componenti visivi in modo che fossero visualizzati nei posti giusti e nella forma giusta.
Fortunatamente, in Android Studio, a partire dalla versione 2.2, invece di costruire un'interfaccia Gimor attraverso layout di disposizione lineare degli elementi (Layout lineare) si propone di utilizzare il nuovo layout forzato (Layoutvincolo). Inoltre, l'editor visivo è stato finalmente finalizzato. Tutto questo insieme ha avuto un effetto molto positivo. Ora non è così difficile posizionare correttamente gli elementi e si comportano in modo abbastanza prevedibile. Ora non puoi nemmeno toccare il markup xml, ma eseguire tutte le azioni nell'editor visivo.
Il linguaggio di programmazione Kotlin, sviluppato dall'azienda JetBrains di San Pietroburgo, è diventato il linguaggio di sviluppo ufficiale per Android. Questo è stato annunciato ufficialmente alla conferenza I/O di Google. Il team di Kotlin è guidato dal laureato dell'Università ITMO Andrey Breslav. Perché Kotlin è così amato dal colosso IT tra molti altri linguaggi "giovani", come e perché compaiono in generale nuovi linguaggi di programmazione, leggete nei commenti degli esperti e nella raccolta di informazioni ITMO.NEWS.
Come vengono sviluppati i linguaggi di programmazione
Secondo varie stime, nel mondo esistono già più di duemila linguaggi di programmazione diversi. Vengono rilasciati costantemente aggiornamenti per le vecchie lingue e compaiono anche nuove lingue. Quando la sintassi di una lingua non cambia, ma diventa solo più complessa e ampliata, allo sviluppatore basta un po' di pratica per continuare a scrivere nella sua lingua preferita. A volte la struttura del linguaggio stesso cambia, e quindi il programmatore a volte deve imparare di nuovo, adattandosi al linguaggio aggiornato. Di solito, la transizione verso una nuova struttura avviene gradualmente e in parti, ovvero solo il 10-20% del codice del programma inizia a essere scritto utilizzando la nuova lingua.
« I programmatori non erano completamente soddisfatti dei linguaggi C++ e Java, perché sono linguaggi piuttosto complessi e il primo è più difficile del secondo. Pertanto è apparso il linguaggio Scala, che piace a molti programmatori, ma è anche molto complesso. La vasta esperienza di JetBrains nella creazione di strumenti di sviluppo di programmi per vari linguaggi di programmazione gli ha permesso di creare in sette anni il linguaggio Kotlin, che è completamente compatibile con Java, ma più semplice e conveniente di esso. I linguaggi di programmazione vengono costantemente sviluppati; nessuno si pone più il compito di creare un linguaggio universale. Nonostante ciò, ogni lingua è più efficace in un determinato ambito in cui viene utilizzata più spesso. C'è anche una direzione nella creazione delle lingue quando vengono sviluppate per un argomento specifico", ha commentato il capo del Dipartimento di Tecnologia di Programmazione dell'Università ITMO.
Oggi alcune aziende compilano addirittura le proprie valutazioni linguistiche. Ad esempio, la società TIOBE, specializzata nella valutazione della qualità dei software, dal 2001 calcola mensilmente l'indice di popolarità di alcune lingue. L'elenco generato contiene 50 righe e affinché un linguaggio di programmazione venga incluso nell'indice, gli sviluppatori devono scrivere una lettera corrispondente all'azienda. Il calcolo si basa sui dati di 25 motori di ricerca Internet. Finora Java è in testa alla classifica con un ampio margine, seguito da C. Allo stesso tempo, i compilatori dell'elenco sottolineano che nell'ultimo anno entrambi i linguaggi di programmazione sono diventati meno popolari, di circa il 6%. Allo stesso tempo, TIOBE mostra che il C era il linguaggio numero 1 fino al 2002, e Java era al 14° posto nel 1997, ma cinque anni dopo ha sostituito il C al primo posto.
Puoi tenere un'ottima conferenza sulla storia dello sviluppo delle lingue: il curatore dei programmi accademici di Yandex, direttore del centro per i concorsi studenteschi presso la Facoltà di Informatica della Scuola Superiore di Economia, parla di come le lingue C , PHP, Ruby e Java sono comparsi. Michail Gustokashin. Il docente sottolinea che per ogni compito dovrebbe essere scelto un linguaggio di programmazione diverso. Ad esempio, dice che per l'industria militare è meglio scrivere nel buon vecchio Pascal, una lingua nata nel 1970! Perché? Perché è più affidabile. Le applicazioni aziendali possono essere scritte in Java perché anche questo linguaggio è abbastanza affidabile, ma molto più facile da usare. L'esperto sottolinea inoltre che è importante mantenere vivo l'interesse per il linguaggio tra i programmatori creando una comunità di sviluppatori che scrivono in questo linguaggio. Se viene creata un’infrastruttura attorno a una nuova lingua e le persone si riuniscono per usarla, solo allora la lingua diventerà popolare. A proposito, anche gli sviluppatori di Kotlin hanno adottato questa strategia.
Un po' di Kotlin
Il linguaggio di programmazione Kotlin ha iniziato ad essere sviluppato presso la società JetBrains di San Pietroburgo nel 2010. La versione ufficiale del prodotto è stata rilasciata nel 2016. La lingua ha ricevuto questo nome in onore dell'isola nel Golfo di Finlandia su cui si trova Kronstadt. Per un'interessante coincidenza, il nome della popolare lingua Java è anche il nome di un'isola dell'Indonesia. Probabilmente la coincidenza non è casuale. Come affermato nel comunicato stampa, Kotlin dovrebbe funzionare ovunque venga eseguito Java e uno degli obiettivi era creare un prodotto che potesse essere utilizzato in progetti misti creati in diverse lingue.
Come notano gli autori di Kotlin, la cosa più importante per loro era creare un prodotto “pragmatico”. Ciò significa che non si concentravano solo sulla correzione dei bug e sul miglioramento del prodotto, cosa che farebbe qualsiasi programmatore, ma volevano creare uno strumento utile.
« Gli strumenti di sviluppo, inclusi i linguaggi di programmazione, sono in continua evoluzione. Le lingue differiscono dagli altri strumenti in quanto sono piuttosto difficili da sviluppare evolutivamente. La nuova versione del linguaggio deve supportare tutti i programmi esistenti. Ciò limita le possibilità di sviluppo delle lingue esistenti e crea la necessità dell'emergere di nuove. Il fattore che determina il successo di un nuovo linguaggio di programmazione è, innanzitutto, la comodità per gli sviluppatori. Oltre ad essere conciso ed espressivo, Kotlin è altamente compatibile con il codice Java: puoi utilizzare tutte le librerie esistenti e persino mescolare codice in due lingue in un unico progetto, quindi non ci sono particolari difficoltà di transizione", ha commentato il project manager Kotlin presso JetBrains, laureato all'Università ITMO.
Perché Google ha amato Kotlin
Sul sito ufficiale gli sviluppatori Android scrivono di aver osservato la “ascesa” di Kotlin negli ultimi anni. I googler non sono timidi nel descrivere il linguaggio come impressionante, conciso, stimolante e piacevole con cui lavorare. Ha aumentato la produttività: il codice del programma in esso contenuto è in media più breve del 40% rispetto ad altri linguaggi e Kotlin consente anche di evitare alcuni errori nel codice. Uno dei fattori determinanti per la popolarità di Kotlin presso Google è stata la sua compatibilità con Java, che viene già utilizzato nello sviluppo di applicazioni per Android.
Ora, quando i programmatori iniziano a creare una nuova applicazione nell'ambiente di sviluppo ufficiale di Android Studio, possono immediatamente abilitare il plug-in "Supporto Kotlin". Puoi anche convertire righe di codice già create in altre lingue nella lingua Kotlin, inserire blocchi in altre lingue in righe di codice in Kotlin. In futuro verranno sviluppate più librerie e strumenti per la lingua, verranno sviluppati più materiali formativi e sarà più facile trovare soluzioni a possibili problemi.
« La mancanza di garanzie di supporto linguistico da parte di Google ha scoraggiato molti sviluppatori dal passare a Kotlin. Anche se ti piace davvero la lingua,Un programmatore pensa sempre al rischio che ad un certo punto questo linguaggio smetta semplicemente di funzionare. Ora c'è la garanzia che Kotlin non smetterà di funzionare e prevediamo che il numero di utenti della lingua aumenterà notevolmente. Sarebbe naturale supporre che molte aziende alla fine passeranno completamente a Kotlin, anche se tecnicamente nulla le obbliga a farlo, è semplicemente una questione di preferenza“- ha sottolineato Andrey Breslav.
Ha aggiunto che Kotlin viene sviluppato molto attivamente. Il team di sviluppo sta attualmente lavorando sul sistema di compilazione, sulla velocità di compilazione, sul miglioramento delle prestazioni dell'IDE, sull'aggiunta di nuove funzionalità al toolkit, comprese quelle relative all'integrazione in Android Studio. Sono in corso anche lavori su progetti multipiattaforma (capacità di compilare lo stesso codice per diverse piattaforme) e una serie di miglioramenti linguistici sono in fase di progettazione.
Google ha inoltre sottolineato di ispirarsi al concetto del linguaggio Kotlin, secondo il quale esso è sempre stato e rimarrà gratuito per gli sviluppatori, cioè un progetto open source. Ciò significa che il linguaggio non è legato a nessuna azienda in particolare e il codice sorgente è distribuito con licenza gratuita. È possibile scaricare il prodotto. Per supportare lo sviluppo di Kotlin, Google e JetBrains creeranno una partnership senza scopo di lucro. Inoltre, come parte della “missione” di Android, è molto importante che gli autori di Kotlin creino attorno al loro prodotto una comunità di persone che siano professionalmente coinvolte nello sviluppo in questo linguaggio e amino condividere la loro esperienza. Ad esempio, a novembre negli Stati Uniti si terrà la conferenza Kotlin e gli sviluppatori potranno anche ricevere quotidianamente notizie e suggerimenti sul prodotto software e incontrarsi a livello locale.
A proposito, il progetto Android Studio stesso è stato sviluppato sulla base dell'ambiente di sviluppo software IntelliJ IDEA, anch'esso creato da JetBrains. Ma nonostante la stretta collaborazione, l'azienda di San Pietroburgo sottolinea che non si parla di vendita di JetBrains al colosso americano dell'informatica. Allo stesso tempo, Koltin non sarà progettato solo per Android. L'obiettivo dell'azienda è rendere il linguaggio di programmazione adatto a diverse piattaforme di sviluppo.
Ultimo aggiornamento: 02/12/2017
Kotlin è un linguaggio di programmazione tipizzato staticamente di JetBrains. Kotlin può essere utilizzato per creare applicazioni mobili e web.
Kotlin viene eseguito sulla Java Virtual Machine (JVM) e viene compilato in bytecode una volta compilato. Cioè, come nel caso di Java, possiamo eseguire un'applicazione Kotlin ovunque sia installata la JVM. Sebbene sia anche possibile compilare il codice in JavaScript ed eseguirlo nel browser. Inoltre, puoi compilare il codice Kotlin in binari nativi che funzioneranno senza alcuna macchina virtuale. Pertanto, la gamma di piattaforme per le quali è possibile creare applicazioni in Kotlin è estremamente ampia: Windows, Linux, Mac OS, iOS, Android.
La prima versione della lingua è stata rilasciata il 15 febbraio 2016. Sebbene lo sviluppo della lingua stessa sia stato effettuato dal 2010. La versione attuale del linguaggio al momento è la versione 1.2, rilasciata il 28 novembre 2017.
Kotlin è stato influenzato da molti linguaggi: Java, Scala, Groovy, C#, JavaScript, Swift e consente di scrivere programmi sia in stile orientato agli oggetti che funzionale. Ha una sintassi chiara e comprensibile ed è abbastanza facile da imparare.
L'area più popolare in cui viene utilizzato Kotlin è principalmente lo sviluppo per il sistema operativo Android. Inoltre, è così popolare che Google alla conferenza Google I/O 2017 ha dichiarato Kotlin uno dei linguaggi ufficiali per lo sviluppo Android (insieme a Java e C++) e gli strumenti per lavorare con questo linguaggio sono stati inclusi di default nella funzionalità dell'ambiente di sviluppo Android Strudio a partire dalla versione 3.0.
Puoi scaricare il compilatore direttamente per il linguaggio Kotlin stesso su .
L'archivio è reperibile all'indirizzo sopra indicato. Scarica e decomprimi la cartella kotlinc dall'archivio. Nell'archivio decompresso nella cartella bin possiamo trovare l'utility kotlinc, che servirà per compilare:
Ora definiamo una directory sul disco rigido per i file del codice sorgente. Ad esempio, nel mio caso la directory si troverà lungo il percorso c:/kotlin. Creiamo un file di testo in questa directory e rinominiamolo app.kt. L'estensione kt è un'estensione dei file nella lingua Kotlin.
Divertente main(argomenti: Array
In questo caso definiamo la funzione principale, che rappresenterà le azioni eseguite dal programma. Per definire una funzione, utilizzare la parola chiave fun.
Questa funzione accetta un parametro args, che rappresenta un array di stringhe.
All'interno della funzione principale viene eseguita un'altra funzione: println(), che stampa alcuni messaggi sulla console.
Apriamo la riga di comando. Innanzitutto, utilizza il comando cd per accedere alla cartella in cui si trova il file app.kt. Quindi, per compilare il programma, immettere il seguente comando:
C:\kotlin\bin\kotlinc app.kt -include-runtime -d app.jar
In questo caso, passiamo il file app.kt al compilatore c:\kotlin\bin\kotlinc per la compilazione. (Per evitare di scrivere il percorso completo nel compilatore, è possibile aggiungere il percorso alla variabile PATH nelle variabili di ambiente). Successivamente, utilizzando il parametro -include-runtime, specifichi che il file generato includerà l'ambiente Kotlin. E il parametro -d specifica come verrà chiamato il file dell'applicazione creata, ovvero in questo caso sarà app.jar .
Dopo aver eseguito questo comando, verrà creato il file app.jar. Ora eseguiamolo. Per fare ciò, inserisci il comando
Java -jar app.jar
In questo caso si presuppone che il percorso del JDK installato sul computer sia specificato nella variabile PATH nelle variabili di ambiente. Altrimenti, invece di "java" dovrai scrivere il percorso completo dell'utilità Java.
Di conseguenza, quando eseguiamo il file, vedremo la riga "Hello Kotlin" sulla console.
Nel 2010, un gruppo di sviluppatori della filiale russa di JetBrains ha deciso di sviluppare un linguaggio che fosse più conveniente e sicuro rispetto ai tipi di Java, ma non così complesso come Scala. Il nome di questa lingua è stato dato in onore dell'isola di Kotlin, situata nel Golfo di Finlandia (per analogia con Giava, da cui prende anche il nome l'isola).
Se guardi qualsiasi recensione moderna dei linguaggi di programmazione più promettenti, incluso, troverai sicuramente Kotlin lì. Qual è l'essenza di questa lingua, perché piace così tanto a tutti, quali prospettive ha - ne parleremo più avanti.
Sintassi
L'idea di creare un linguaggio che sia ugualmente conveniente sia per i principianti che per gli sviluppatori esperti è espressa direttamente nella sua sintassi. Come ogni analogo moderno, Kotlin è estremamente conciso, compatto e comprensibile. Un'enorme quantità di codice che prima doveva essere scritta in Java ora può essere semplicemente ignorata. Un semplice esempio: l'uso del punto e virgola per separare le istruzioni non è un requisito: il compilatore ora capisce tutto da solo se si passa a una nuova riga. Quando si dichiarano le variabili, in molti casi non è necessario specificarne il tipo: verrà determinato automaticamente.
Allo stesso tempo, va detto che Kotlin, in termini di registrazione, è tornato un po' allo stile Pascal: anche qui la chiarezza prevale sulla chiarezza delle strutture. Puoi leggere qualcosa in più a riguardo in questo breve articolo. Copre solo i principi di base della costruzione dei linguaggi Java e Kotlin, quindi sarà comprensibile a tutti.
Tuttavia, lasceremo comunque un piccolo pezzo di codice:
divertente main(argomenti: Array
ambito val = "mondo"
println("Ciao $scope!")
}
Una voce estremamente semplice che dovrebbe essere comprensibile a chiunque abbia studiato programmazione a scuola o all'università per almeno un anno.
È importante ricordare che Kotlin è completamente compatibile con Java. Ecco perché all'inizio veniva considerato un semplice zucchero sintattico, utilizzato per compiti complessi in cui si voleva semplicemente risparmiare tempo e fatica.
Vantaggi
In generale, tutti i vantaggi rispetto a Java sono già stati menzionati, quindi li raccoglieremo in un unico posto:
Volume del codice. Non utilizzare pezzi di codice arcaici non necessari accelera il processo di sviluppo e aumenta la leggibilità;
Sicurezza. Le regole per la creazione del codice incorporate nella sintassi del linguaggio consentono di evitare piccoli errori difficili da tracciare che si verificano solo durante l'esecuzione del programma;
Compatibilità con Java. Ciò è conveniente sia dal punto di vista dell'apprendimento di una nuova lingua, sia dal punto di vista del trasferimento graduale dei propri prodotti software da Java a Kotlin. Ad esempio, questo è esattamente quello che è successo con l'applicazione Basecamp.
Screpolatura
Essendo un linguaggio sviluppato sulla base di Java, Kotlin presenta due evidenti svantaggi in confronto: velocità ed elaborazione. Nel primo caso tutto è chiaro: lavorando sulla JVM è difficile battere Java in termini di prestazioni. Il secondo problema è un po’ inverosimile per una lingua così giovane, perché è in circolazione ufficiale da poco più di un anno. Sì, qui ci sono molti meno strumenti e librerie che in Java. Ma, in primo luogo, questo non è ancora fondamentale e, in secondo luogo, nel mondo Java la quantità non si è sempre tradotta in qualità.
Kotlin, per ora, fa fronte ai suoi compiti principali e la piena compatibilità con Java aiuta a chiudere gli occhi su queste lacune.
Prospettive
Nonostante lo sviluppo di Kotlin sia iniziato nel 2010, la prima versione ufficiale è stata rilasciata solo nel febbraio 2016. Da allora, la richiesta per la lingua è cresciuta rapidamente, nella classifica TIOBE è entrata nella TOP-50 entro un anno , e il mese scorso alla conferenza Google I /O ha annunciato il supporto ufficiale per Kotlin nel sistema di sviluppo di applicazioni Android.
Considerando l'elevata popolarità di IntelliJ IDEA tra gli sviluppatori e l'attenzione strategica dell'azienda su Kotlin, possiamo affermare con sicurezza che tra 3-4 anni lo vedremo tra i concorrenti a pieno titolo di Java e Swift nel campo dello sviluppo mobile. Inoltre, se i creatori del linguaggio non rimarranno delusi dal loro prodotto, Kotlin continuerà sicuramente a conquistare seriamente altri orizzonti: web, intelligenza artificiale, Internet delle cose, big data, applicazioni desktop.
Se sei seriamente interessato a questa lingua, assicurati di dare un'occhiata al suo sito web ufficiale (versione russa) e sperimenta tutti i suoi vantaggi per esperienza personale. Affrettatevi prima che diventi mainstream.