Beste antwoord
Om uw vraag te beantwoorden, hangt het af van wat u bedoelt met “java-code”. Scala-code is legale Java-code, u hoeft alleen de scala.jar toe te voegen aan het Java-klassenpad. scalac is slechts een omhulsel rond het java-commando dat het juiste hoofdobject doorgeeft en het klassenpad correct instelt. (roep $ vim `which scalac` aan om dit script te zien).
Als u bijvoorbeeld een Mac gebruikt met de Typesafe Scala-stack, kunt u de Scala-code die u in myFile.scala vindt, daadwerkelijk compileren met behulp van het commando :
java -Dscala.home=/Applications/typesafe-stack/ -D.scala.usejavacp=true -cp .:/Applications/typesafe-stack/lib/scala-library.jar:/Applications/typesafe-stack/lib/scala-compiler.jar scala.tools.nsc.Main myFile.scala
Ik zal hieronder wat meer uitleg geven, maar ik accepteer graag bewerkingen van Scala-experts die er zijn.
Laten we het volgende eenvoudige scala-object nemen (dat ik heb gecompileerd maar niet heb getest …)
class Adder(val x:Int){
def add(y:Int) = x+y
def applyFunction(f: Int=>Int) = f(x)
}
Het is een domme methode. Er is een int nodig, en je kunt er dan een andere int aan toevoegen of een functie toepassen op dat gehele getal.
We noemen scalac en genereren de class-bestanden. Nu kunnen we de java dissasembler, javap aanroepen om de werkelijk gegenereerde velden en klassemethoden te bekijken.
$ javap Adder
public class Adder breidt java.lang.Object uit met scala.ScalaObject {public int x (); openbare int add (int); openbare int applyFunction (scala.Function1); openbare Adder (int); }
Dit is een prima Java-object dat expliciet met Java zou kunnen worden geïmplementeerd.
Nu moet je voorzichtig zijn met het gebruik van meer geavanceerde Scala-technieken, zoals eigenschappen.
Laten we dit codeblok eens bekijken
abstract class Thing {
def method:Unit
}
trait OtherThing {
def method { println("Hello")}
}
object Main{
def main(args: Array[String]) = {
val A = new Thing with OtherThing
A.method
}
}
Je hebt een abstracte klasse waarvan de methode is geïmplementeerd in een eigenschap die wordt gemengd tijdens de objectdefinitietijd.
Als je dit compileert, zul je veel meer klassen zien met funky $ symbolen en het woord anon. De meest interessante is de klasse gevonden in Main $$ anon $ 1. class.
Als we javap Main $$ anon $ 1 aanroepen, zien we dat we ed een nieuwe klas
public final class Main$$anon$1 extends Thing implements OtherThing{
public void method();
public Main$$anon$1();
}
die Java-interfaces en subclassificatie gebruikt om deze klasse correct weer te geven.
Geweldig, toch?
Antwoord
Nee. Scala is een geweldige programmeertaal op papier, maar het zal niet van de grond komen. Bekijk de evolutie van het gebruik in de onderstaande grafiek:
Kun je de lichtblauwe lijn zien die Scala voorstelt? Nee? Nou, het vertegenwoordigt ongeveer 2\% van de pull-verzoeken in Github (bekijk meer statistieken hier ). De curve is niet alleen vlak, hij is zelfs iets lager dan 2,3\% vijf jaar geleden. Dat is ondanks het feit dat Spark , het meest populaire Scala-project, in 2014 werd uitgebracht.
Dus nee, Scala is op geen enkele manier zal opstijgen ondanks wat velen van ons dachten toen we de taal voor het eerst gebruikten. Wat kan er fout gaan? Een taal die werkt in de beproefde JVM en die de flexibiliteit biedt om te worden gebruikt als gewoon “een betere java” of “volledig functioneel” te gaan, of zelfs andere aardigheden zoals acteurs of toekomsten leken een uitkomst.
In de praktijk blijkt dat het anders werkt. Scala is nog een andere taal die u moet ondersteunen, tenzij u alles in Scala kunt doen, wat zeer onwaarschijnlijk is. Je combineert in ieder geval Scala en Java, dus waarom zou je jezelf niet beperken tot Java? Dat lijkt de belangrijkste reden te zijn dat LinkedIn besloot om het gebruik van Scala in hun stapel geleidelijk stop te zetten.
Maar het wordt eigenlijk erger, Scala, vanwege zijn ontwerp en flexibiliteit, is op zichzelf lastig om vol te houden . Het is net als C ++, maar erger. U kunt bijvoorbeeld ervaren Scala-programmeurs gek maken met een volledig functionele codeerstijl om een waanzinnige hoeveelheid informatie in een regel code te verpakken die een nieuweling niet zal begrijpen. Dus als je een Scala-codebasis wilt behouden, moet je behoorlijk strikt zijn over “hoe” je het moet gebruiken. En dan moet je eropuit gaan en ontwikkelaars inhuren die Scala op die bepaalde manier kunnen en willen coderen. Succes daarmee. Zelfs Twitter, de krachtpatser van Scala, zei dat ze Scala niet zouden kiezen als hun programmeertaal als ze het vandaag moesten doen (of in 2015 om meer beton). Yammer is om vergelijkbare redenen ook van Scala naar Java verhuisd.
Het blijkt dus dat Scala niet alleen niet van de grond komt, maar in werkelijkheid waarschijnlijk op weg is, alleen in stand gehouden door de populariteit van Spark. Eigenlijk is Scala erg goed voor gegevens, dus de keuze is logisch. Het zou me echter niet verbazen als mensen na verloop van tijd Python als de standaard Spark-taal gaan gebruiken, gezien hoe populair het aan het worden is onder datawetenschappers.
Update:
Voor degenen die beweren dat Github geen goede weergave is van de populariteit van de taal, zijn hier een paar meer: Scala komt niet eens voor in Tiobes top 20 , volgens PyPL , gebaseerd op Google zoekt, de populariteit is 1,2\%, hoewel ze een lichte stijging meten. U kunt hier veel andere indices vinden. Ik denk niet dat er iets te zien is, zelfs niet in de buurt van de taal “opstijgen”.