Imparare Scala come prima VM/Compiled language - Sfide di flusso di lavoro

Question

Vengo da uno sfondo PHP/Python/Javascript, e di recente sono diventato molto interessato a Scala - in particolare Akka proveniente dal web.

Sto attraversando un periodo estremamente difficile con un flusso di lavoro generale, problemi rispetto ai linguaggi interpretati come quelli che ho descritto.

In generale tendo a codificare, verificare i risultati, codice e ripetere. Questo si blocca quando anche la modifica di una singola linea in una classe di 20 righe richiede fino a 30 secondi per la compilazione e l'esecuzione. È normale? Devo solo costruire, costruire, costruire poi tornare indietro di 30 minuti o un'ora dopo e compilare/testare?

(Uso IDEA con SBT) Devo imparare in modo specifico come utilizzare Maven oltre al collegamento ai repository?

Pensieri? Consigli?

Answer 1

Penso che tu sia sulla strada giusta con Idea e SBT. Hai provato

~compile 

Che rileverà automaticamente le modifiche alla tua fonte. Per le applicazioni web, si può fare un

jetty-run 

seguito da

~prepare-webapp 

Per compilare in modo continuo e ridistribuire l'app per pontile. Fa sì che Scala si senta molto simile allo sviluppo web di Python.

In genere ho trovato SBT molto veloce durante la compilazione, in particolare il file di dimensioni di cui si sta parlando. Nel momento in cui salvi la mia modifica e vado al mio prompt SBT, è fatto.

Un altro aspetto utile SBT è il REPL che caricherà il vostro progetto e le sue dipendenze:

console 

è possibile ricaricare eventuali modifiche compilati con

:replay 

nel REPL Scala.

MODIFICA: Indovinate, dovrei dire che si può giocare con una semplice lezione con un metodo principale. Se si crea un file chiamato src/main/Scala/Foo.scala che assomiglia a questo:

object Foo { 
    def main(args: Array[String]) { 
    println("Hello World") 
    } 
} 

E un progetto di file/costruire/Build.scala come questo:

import sbt._ 
class Build(info: ProjectInfo) extends DefaultProject(info) { 
    override def mainClass = Some("Foo") 
} 

Poi alla prompt sbt, è possibile eseguire

~run 

Per compilare ed eseguire in modo continuo il metodo Foo.main. Prima potrebbe essere necessario eseguire una "ricarica" ​​in SBT. Ci sono voluti 2-3 secondi dal salvataggio delle modifiche alla visualizzazione dell'output. Quindi basta modificare, salvare e vedere le modifiche. È un buon flusso di lavoro.

Inoltre, non dimenticare la REPL - sicuramente uno strumento fondamentale per l'apprendimento di Scala. Puoi imparare una tonnellata semplicemente giocando con essa in modo interattivo.

Answer 2

IDE Assistenza:

Con lingua tipizzazione statica mi ritrovo a fare a meno di quel flusso di lavoro che io faccio con la tipizzazione dinamica, ma che è stato possibile solo perché l'assistenza IDE eccellente (le informazioni digitazione consente di rilevare errori precoci e dare suggerimenti accurati mentre stai modificando), quindi fa risparmiare un po 'di tempo nel ciclo di test del codice che hai descritto.

Tuttavia il supporto IDE di Scala in IDEA non è ancora al livello di Java, ad esempio, sia in errori di acquisizione durante la modifica (IMHO) e velocità di compilazione.

REPL supporto/Script:

Non dimenticate che è comunque possibile utilizzare la Scala REPL, il flusso di lavoro è più o meno simile a quello che sarebbe stato utilizzato per in Python, per esempio.

IDEA + velocità Scala:

è possibile fare riferimento al this question per ulteriori discussioni sulla velocità Scala IDEA +.

Answer 3

Uno dei vantaggi delle lingue tipizzate staticamente è che il sistema di tipi può catturare diversi tipi di errori/bug. Quindi, in teoria, non dovresti aver bisogno di passare la trafila abbastanza spesso.

Ovviamente ci sono molti cambiamenti, specialmente nell'interfaccia utente, che solo gli occhi sullo schermo possono controllare. Tutto quello che posso suggerire è una buona modularizzazione per mantenere basso il tempo di compilazione/compilazione. E unit test. Non so della community da cui vieni, ma in java/scala, i test unitari sono altamente raccomandati. Scopri se il codice ha funzionato molto più velocemente in quel modo.

La risposta si riduce a questa: cerca di evitare di dover costruire e riavviare per controllare il tuo lavoro il più possibile.

Answer 4

Uso il plug-in JRebel con maven. Spengo la compilazione NetBeans per la funzione di salvataggio, (non so se lo intellij è simile) ed esegui scala:cc - obiettivo di compilazione continua dalla console. Aspetta qualsiasi cambiamento nel codice sorgente, quindi dopo averne fatto un po ', il file viene compilato, copiato nella directory /target e poi hotswapped nella macchina virtuale in esecuzione. La procedura richiede unità di secondi in base alla dimensione del file. (Suppongo che tu sviluppi web da quando hai menzionato PHP e JavaScript) C'è il server fsc in esecuzione in background, che è anche uno dei motivi per cui la compilazione viene accelerata su.
Ci sono alcuni svantaggi minori, non è possibile cambiare la superclasse, il che significa che non è possibile passare da AbstractFunction1 a AbstractFunction2 (che rappresentano funzioni anonime) - la modifica di (x) => x a (x,y) => x + y significa che è necessario riavviare il server.
Link utili:
scala:cc
jrebel

Answer 5

mio Python-like del flusso di lavoro - il che mi lascia con poco tempo di attesa - di solito è la seguente:

• Accendere quello che sto cercando da fare in una libreria (incollarla in un .jar e aggiungerla al classpath).

• Lavorare sul nuovo codice in un editor, ma incollarlo nel REPL anziché compilare separatamente. Una volta che funziona bene, aggiungi un test unitario.

• Inserire il nuovo codice nella libreria. Ripetere.

Posso farlo su un netbook e non aspettare più di ~ 3 secondi per ogni passo.