Adotta Kotlin per grandi team

Passare a una nuova lingua può essere un compito arduo. La ricetta del successo è inizia lentamente, procedi in blocchi e testa spesso per allineare il tuo team al successo. Kotlin semplifica la migrazione, poiché si compila in bytecode JVM e è completamente interoperabile con Java.

Creazione del team

Il primo passaggio prima della migrazione consiste nel creare una comprensione di base comune il tuo team. Di seguito sono riportati alcuni suggerimenti utili per accelerare dell'apprendimento del team.

Creare gruppi di studio

I gruppi di studio sono un modo efficace per facilitare l'apprendimento e la fidelizzazione. Gli studi suggeriscono che recitare ciò che si ha imparato in un gruppo aiuta rafforzano il materiale. Ricevi un Kotlin book o altro materiale di studio per ogni membro del gruppo e chiedi a quest'ultimo di seguire due capitoli ogni settimana. Durante ogni riunione, il gruppo deve confrontare appreso e discutendo di eventuali domande o osservazioni.

Costruisci una cultura dell'insegnamento

Non tutti si considerano insegnanti, ma tutti possono insegnare. Dal responsabile della tecnologia o del team a un singolo collaboratore, tutti possono incoraggiare un ambiente di apprendimento che possa contribuire a garantire il successo. Sola andata è facilitare l'esecuzione di presentazioni periodiche in cui una persona del team è designato per parlare di qualcosa che hanno imparato o che vogliono condividere. Puoi sfrutta il tuo gruppo di studio chiedendo ai volontari di presentare un nuovo capitolo ciascuno settimana finché non arrivi a un punto in cui il tuo team si sente a suo agio con lingua.

Designa un campione

Infine, designa un sostenitore che conduca un'attività di apprendimento. Questa persona può un esperto in materia (SME) non appena inizi il processo di adozione. È è importante includere questa persona in tutte le riunioni di esercitazione relative all' Kotlin. Idealmente, questa persona è già appassionata di Kotlin e ha conoscenze lavorative.

Integra lentamente

Iniziare lentamente e pensare in modo strategico a quali parti del tuo ecosistema per prima cosa è la chiave. Spesso è meglio limitarlo a una singola app all'interno piuttosto che un'app di punta. Per quanto riguarda la migrazione dell'app scelta, ogni situazione è diversa, ma ecco alcuni punti di partenza comuni.

Modello dei dati

Il modello dei dati probabilmente è costituito da molte informazioni sullo stato e di machine learning. Il modello dei dati potrebbe anche avere metodi comuni come toString(), equals() e hashcode(). Questi metodi in genere possono essere trasferiti e facilmente testati in modo isolato.

Ad esempio, supponiamo che il seguente snippet di Java:

public class Person {

   private String firstName;
   private String lastName;
   // ...

   public String getFirstName() {
       return firstName;
   }

   public void setFirstName(String firstName) {
       this.firstName = firstName;
   }

   public String getLastName() {
       return lastName;
   }

   public void setLastName(String lastName) {
       this.lastName = lastName;
   }

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Person person = (Person) o;
       return Objects.equals(firstName, person.firstName) &&
               Objects.equals(lastName, person.lastName);
   }

   @Override
   public int hashCode() {
       return Objects.hash(firstName, lastName);
   }

   @Override
   public String toString() {
       return "Person{" +
               "firstName='" + firstName + '\'' +
               ", lastName='" + lastName + '\'' +
               '}';
   }
}

Puoi sostituire la classe Java con una singola riga di Kotlin, come mostrato di seguito:

data class Person(var firstName: String?, var lastName : String?)

Questo codice può quindi essere testato nell'unità rispetto alla suite di test corrente. L'idea in questo caso è iniziare in piccolo con un modello alla volta e le classi di transizione che dichiarano e non comportamenti. Assicurati di eseguire spesso dei test durante il processo.

Esegui la migrazione dei test

Un altro percorso iniziale da considerare è quello di convertire i test esistenti e iniziare a scrivere nuovi test in Kotlin. Questo può dare al tuo team il tempo di sentirsi a proprio agio con le prima di scrivere il codice che prevedi di distribuire con la tua app.

Spostare i metodi di utilità nelle funzioni di estensione

Qualsiasi classe di utilità statica (StringUtils, IntegerUtils, DateUtils, YourCustomTypeUtils e così via) possono essere rappresentate come Funzioni dell'estensione Kotlin e usato dal codebase Java esistente.

Ad esempio, supponiamo di avere una classe StringUtils con alcuni metodi:

package com.java.project;

public class StringUtils {

   public static String foo(String receiver) {
       return receiver...;  // Transform the receiver in some way
   }

   public static String bar(String receiver) {
       return receiver...;  // Transform the receiver in some way
   }

}

Questi metodi potrebbero quindi essere utilizzati altrove nella tua app, come mostrato nell' nell'esempio seguente:

...

String myString = ...
String fooString = StringUtils.foo(myString);

...

Utilizzando le funzioni dell'estensione Kotlin, puoi fornire la stessa interfaccia Utils per chiamanti Java e, allo stesso tempo, offre un'API più concisa in crescita nel codebase Kotlin.

Per farlo, puoi iniziare convertendo questa classe Utils in Kotlin utilizzando conversione automatica fornita dall'IDE. L'output di esempio potrebbe essere simile a le seguenti:

package com.java.project

object StringUtils {

   fun foo(receiver: String): String {
       return receiver...;  // Transform the receiver in some way
   }

   fun bar(receiver: String): String {
       return receiver...;  // Transform the receiver in some way
   }

}

Successivamente, rimuovi la definizione della classe o dell'oggetto e aggiungi il prefisso a ogni nome di funzione a cui deve essere applicata questa funzione e usalo per fare riferimento al tipo all'interno della funzione, come mostrato nell'esempio seguente:

package com.java.project

fun String.foo(): String {
    return this...;  // Transform the receiver in some way
}

fun String.bar(): String {
    return this...;  // Transform the receiver in some way
}

Infine, aggiungi un'annotazione JvmName nella parte superiore del file di origine per rendere un nome compilato compatibile con il resto dell'app, come mostrato di seguito esempio:

@file:JvmName("StringUtils")
package com.java.project
...

La versione finale dovrebbe essere simile alla seguente:

@file:JvmName("StringUtils")
package com.java.project

fun String.foo(): String {
    return this...;  // Transform `this` string in some way
}

fun String.bar(): String {
    return this...;  // Transform `this` string in some way
}

Tieni presente che ora queste funzioni possono essere chiamate utilizzando Java o Kotlin con convenzioni che corrispondono a ogni lingua.

Kotlin

...
val myString: String = ...
val fooString = myString.foo()
...

Java

...
String myString = ...
String fooString = StringUtils.foo(myString);
...

Completa la migrazione

Una volta che il tuo team si sente a suo agio con Kotlin e che hai eseguito la migrazione di aree più piccole, puoi passare ad affrontare componenti più grandi come frammenti, attività ViewModel oggetti e altra classe correlate alla logica di business.

Considerazioni

Proprio come Java ha uno stile specifico, Kotlin ha un proprio stile idiomatico che contribuisce alla sua concisione. Tuttavia, all'inizio potresti scoprire che Il codice Kotlin prodotto dal tuo team assomiglia più al codice Java che sta sostituendo. Questo cambia nel tempo man mano che l'esperienza Kotlin del tuo team cresce. Ricorda che, gradualmente il cambiamento è la chiave del successo.

Ecco alcune cose che puoi fare per ottenere la coerenza del tuo codebase Kotlin Crescita:

Standard di programmazione comuni

Assicurati di definire un insieme standard di convenzioni di codifica sin dall'adozione e il processo di sviluppo. Puoi divergerti da Android Guida di stile di Kotlin, dove ha senso.

Strumenti di analisi statica

Applica gli standard di programmazione impostati per il tuo team utilizzando Android Lint e altri strumenti di analisi statica. klint, un'app Kotlin di terze parti linter, fornisce anche regole aggiuntive per Kotlin.

Integrazione continua

Assicurati di rispettare gli standard di codifica più comuni e di eseguire test sufficienti per il tuo codice Kotlin. Rendere questa parte del processo di compilazione automatizzato può contribuire a garantire la coerenza e il rispetto di questi standard.

Interoperabilità

Per la maggior parte, Kotlin interagisce con Java senza problemi, ma tieni presente seguire.

Nullabilità

Kotlin si basa sulle annotazioni dei valori NULL nel codice compilato per dedurre dal lato Kotlin. Se le annotazioni non vengono fornite, Kotlin utilizza per impostazione predefinita una tipo di piattaforma che può essere trattata come tipo con o senza valori null. Questo possono causare problemi di runtime NullPointerException, ma se non vengono gestiti con attenzione.

Adotta nuove funzionalità

Kotlin offre molti nuove librerie e lo zucchero sintattico per ridurre il boilerplate, contribuendo ad aumentare lo sviluppo la velocità. Detto questo, sii prudente e metodico quando utilizzi lo standard di funzioni libreria, come funzioni di raccolta, coroutine, e lambdas.

Ecco una trappola molto comune che si trovano a dover affrontare i nuovi sviluppatori Kotlin. Supponiamo che seguente codice Kotlin:

val nullableFoo: Foo? = ...

// This lambda executes only if nullableFoo is not null
// and `foo` is of the non-nullable Foo type
nullableFoo?.let { foo ->
   foo.baz()
   foo.zap()
}

L'intento in questo esempio è eseguire foo.baz() e foo.zap() se nullableFoo non è nullo, evitando così un NullPointerException. Anche se questo il codice funziona come previsto, è meno intuitivo da leggere rispetto a un semplice controllo null smart Cast, come mostrato nell'esempio seguente:

val nullableFoo: Foo? = null
if (nullableFoo != null) {
    nullableFoo.baz() // Using !! or ?. isn't required; the Kotlin compiler infers non-nullability
    nullableFoo.zap() // from guard condition; smart casts nullableFoo to Foo inside this block
}

Test

Per impostazione predefinita, in Kotlin le classi e le relative funzioni sono chiuse per l'estensione. Tu deve aprire esplicitamente le classi e le funzioni da creare sottoclassi. Questo è una decisione di progettazione linguistica che è stata scelta per promuovere la composizione sull'ereditarietà. Kotlin supporta integrato per implementare il comportamento tramite delega per semplificare la composizione.

Questo comportamento pone un problema a framework fittizi, come Mockito, che fare affidamento sull'implementazione o sull'ereditarietà dell'interfaccia per ignorare i comportamenti durante test. Per i test delle unità, puoi abilitare l'utilizzo della classe Mock Maker in linea funzionalità di Mockito, che ti consente di simulare classi e metodi finali. In alternativa, puoi utilizzare plug-in del compilatore completamente aperto per aprire qualsiasi corso Kotlin e i relativi membri che vuoi testare nell'ambito una procedura di compilazione. Il vantaggio principale dell'utilizzo di questo plug-in è che funziona sia con test delle unità che con i test strumentati.

Ulteriori informazioni

Per ulteriori informazioni sull'utilizzo di Kotlin, consulta i seguenti link: