സ്കാല (പ്രോഗ്രാമിങ് ഭാഷ)

ഇംഗ്ലീഷ് വിലാസം

https://ml.wikipedia.org/wiki/Scala_(programming_language)

സ്കാല

ശൈലി:	Multi-paradigm: concurrent, functional, imperative, object-oriented
പുറത്തുവന്ന വർഷം:	20 ജനുവരി 2004; 20 വർഷങ്ങൾക്ക് മുമ്പ് (2004-01-20)
രൂപകൽപ്പന ചെയ്തത്:	Martin Odersky
വികസിപ്പിച്ചത്:	Programming Methods Laboratory of École Polytechnique Fédérale de Lausanne
ഡാറ്റാടൈപ്പ് ചിട്ട:	Inferred, static, strong, structural
സ്വാധീനിച്ചത്:	Ceylon, Chisel, Fantom, F#, C#, Kotlin, Lasso, Red, Flix
അനുവാദപത്രം:	Apache 2.0[1]
വെബ് വിലാസം:	www.scala-lang.org

സ്കാല (Scala) ഒരു പൊതു ഉപയോഗ പ്രോഗ്രാമിങ് ഭാഷയാണ്. ഇത് ഫങ്ഷണൽ പ്രോഗ്രാമിങ്ങിനും ശക്തമായ സ്റ്റാറ്റിക് ടൈപ്പ് സിസ്റ്റത്തിനും പിന്തുണ നൽകുന്നു. സ്കാല സോഴ്സ് കോഡ് ജാവ ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യാൻ ഉദ്ദേശിച്ചുള്ളതാണ്, അങ്ങനെ സംഭവിക്കുന്ന കൃത്യനിർവഹണ കോഡ് ജാവ അയഥാർത്ഥ (വെർച്ച്വൽ) സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്നു. സ്കാല ജാവയിൽ ഭാഷയുടെ പരസ്പരമുള്ള പ്രവർത്തനക്ഷമത നൽകുന്നു, അതിനാൽ രണ്ട് ഭാഷകളിലും എഴുതപ്പെട്ട ലൈബ്രറികൾ സ്കാലയിലോ ജാവ കോഡിലോ നേരിട്ട് പരാമർശിക്കപ്പെടാം. ജാവയെ പോലെ, സ്കാല ഓബ്ജക്റ്റ് ഓറിയൻറഡ് ആണ്, കൂടാതെ സി പ്രോഗ്രാമിങ് ഭാഷയുടെ ഓർമ്മപ്പെടുത്തലായി ഒരു വളഞ്ഞ ബ്രേസ് സിൻറാക്സ് ഉപയോഗിക്കുന്നു. ജാവയിൽ നിന്നും വ്യത്യസ്തമായി സ്കീം സ്റ്റാൻഡേർഡ് എം.എൽ., ഹാസ്കൽ തുടങ്ങിയ പ്രോഗ്രാമിങ് ഭാഷകളെ സ്കാലയിൽ പല ഘടകങ്ങളുമായി ബന്ധപ്പെടുത്തിയിരിക്കുന്നു. കറിയിങ്, അനുമാനതരങ്ങൾ, അപര്യാപ്തത, അലസമായ മൂല്യനിർണ്ണയം, മാത‌‌ൃക പൊരുത്തപ്പെടൽ എന്നിവയുൾപ്പെടെ നിരവധി സവിശേഷതകളുണ്ട്. ജാവയിൽ ഇല്ലാത്ത സ്കാലയുടെ മറ്റ് ഫീച്ചറുകൾ ഈ പറയുന്നവയാണ് ഓപ്പറേറ്റർ ഓവർലോഡിംഗ്, ഇച്ഛാനുസൃതമായ പരിധികൾ, നാമപരിധികൾ, അസംസ്കൃത സ്ട്രിംഗ്സ് എന്നിവയാണ്. അതുപോലെ, സ്കാലയിൽ ഇല്ലാത്ത ജാവയുടെ ഒരു സവിശേഷത ഒഴിവാക്കലുകൾ പരിശോധിക്കുകയാണ്.

സ്കാല അളവും വലിപ്പവും മാറ്റാവുന്ന ഭാഷ ആയതിനാൽ, അതിൻറെ ഉപയോക്താക്കളുടെ ആവശ്യങ്ങൾക്കനുസൃതമായി വളരാൻ പാകത്തിലാണ് രൂപകൽപന ചെയ്യുന്നതിരിക്കുന്നത്.

2001 ൽ സ്കാലയുടെ രൂപകൽപ്പന മാർക്കോ ഒഡേർസ്സ്കി ഇക്കോൾ പോളിടെക്നിക് ഫെഡെറലെ ഡെ ലൗസനെയിൽ (ഇ.പി.എഫ്.എൽ.) (ലോസാനിൽ, സ്വിറ്റ്സർലണ്ടിൽ) ആരംഭിച്ചു. ഓഡേഴ്സ്കി മുൻപ് ജനറിക് ജാവയിലും ജാവാക്, സൺസ് ജാവാ കമ്പൈലറിലും പ്രവർത്തിച്ചു.

2003 ൻറെ അന്ത്യത്തിൽ, 2004-ൽ ജാവ പ്ലാറ്റ്ഫോമിൽ സ്കാല പുറത്തിറങ്ങി. 2006 മാർച്ചിൽ രണ്ടാം പതിപ്പ് (v2.0).

ഫംഗ്ഷൻ പ്രോഗ്രാമിന് തുടക്കം കുറിച്ച സ്കാലയ്ക്ക് വലിയ പിന്തുണ ഉണ്ടായിരുന്നെങ്കിലും, ജാവാ 8 ഉപയോഗിച്ച് ലാംഡ എക്സ്പ്രഷനുകൾ ഉൾപ്പെടുത്തുന്നത് വരെ ജാവ ഒരു ഒബ്ജക്റ്റ് ഓറിയൻറഡ് ഭാഷയായി തുടർന്നു.

2011 ജനുവരി 17 ന് യൂറോപ്യൻ റിസേർച്ച് കൗൺസിലിൽ നിന്ന് സ്കാല ടീമിന് 2.3 മില്ല്യൺ യൂറോ കിട്ടി. 2011 മേയ് 12-ന് ഓഡേഴ്സ്സ്കിയും സഹകാരികളും ടൈപ്സേഫ് എന്ന കമ്പനി (പിന്നീട് ലൈറ്റ്ബെൻഡ് ഇൻക്. എന്ന പേരിൽ പുനർനാമകരണം ചെയ്തു) സ്കാലയ്ക്ക് വാണിജ്യ പിന്തുണയും പരിശീലനവും സേവനങ്ങളും പ്രദാനം ചെയ്തു. ടൈപ്സേഫിന് 2011 ൽ ഗ്രൈലോക്ക് പാർട്ട്നേഴ്സിൽ നിന്ന് 3 മില്യൺ ഡോളർ നിക്ഷേപവും ലഭിച്ചു.

സ്കാല ജാവ പ്ലാറ്റ്ഫോമിൽ പ്രവർത്തിക്കുന്നു (ജാവ വെർച്വൽ മെഷീൻ) നിലവിലുള്ള ജാവാ പ്രോഗ്രാമുകൾക്ക് അനുയോജ്യമാണ്. ആൻഡ്രോയ്ഡ് ആപ്ലിക്കേഷനുകൾ സാധാരണയായി ജാവയിൽ എഴുതുകയും ജാവ ബൈറ്റ്കോഡിൽ നിന്ന് ഡാൽവിക് ബൈറ്റ്കോഡായി (ഇൻസ്റ്റാളേഷൻറെ സമയത്ത് സ്വതഃസിദ്ധമായ യന്ത്ര ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യാവുന്നതാണ്), പാക്കേജു ചെയ്യുമ്പോൾ, സ്കാലയുടെ ജാവ അനുയോജ്യത ആൻഡ്രോയ്ഡ് വികസനത്തിന് ഏറെ അനുയോജ്യമാണ്, ഒരു ഫങ്ഷണൽ സമീപനം തിരഞ്ഞെടുക്കുമ്പോൾ കൂടുതൽ സ്വീകാര്യത ലഭിക്കുന്നു.

കമ്പൈലറും ലൈബ്രറികളും ഉൾപ്പെടെ റഫറൻസ് സ്കാല സോഫ്റ്റ്‌വേർ വിതരണമാണ് ബിഎസ്ഡി ലൈസൻസിനു കീഴിൽ റിലീസ് ചെയ്യപ്പെടുന്നത്.

സ്കാല.ജെഎസ് എന്നത് ഒരു സ്കാല കംപൈലറാണ്, അത് ജാവാസ്ക്രിപ്റ്റിലേക്ക് സമാഹരിക്കുന്നു, ഇത് വെബ് ബ്രൌസറുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന സ്കാല പ്രോഗ്രാമുകൾ എഴുതുന്നത് സാധ്യമാക്കുന്നു.

സ്കാല നേറ്റീവ് ഒരു സ്കാല കംപൈലർ ആണ്, ഇത് എൽഎൽവിഎം കമ്പൈലർ ഇൻഫ്രാസ്ട്രക്ചറിനെ ലക്ഷ്യമിടുന്നു. ഇത് ലൈറ്റ്-വെയിറ്റ് മാനേജുമെന്റ് റൺടൈം ഉപയോഗിയ്ക്കാവുന്ന കോഡ് ഉണ്ടാക്കുന്നു. ഇത് ബോഹെം ഗാർബേജ് കളക്ടറെ പ്രയോജനപ്പെടുത്തുന്നു. ഡെനിസ് ഷബലിൻ ആണ് ഈ പദ്ധതി നയിക്കുന്നത്, 2017 മാർച്ച് 14 ന് അതിൻറെ 0.1 പുറത്തിറങ്ങുകയും ചെയ്തു. കോഡിന്റെ പ്രാരംഭ റൈറ്റ് കംപൈലേഷൻ ഒഴിവാക്കി ജെവിഎമ്മിനു വേണ്ടി ജസ്റ്റ്-ഇൻ-ടൈം കമ്പൈലേഷൻ എന്നതിനേക്കാൾ വേഗത്തിൽ ലക്ഷ്യം നേടാൻ സ്കാല നേറ്റീവ് ഡെവലപ്പ്മെൻറ് 2015-ൽ ആരംഭിച്ചു.

.നെറ്റ് ഫ്രെയിംവർക്കിനെ ലക്ഷ്യം വയ്ക്കുന്ന ഒരു റഫറൻസ് സ്കാല കമ്പൈലർ, 2004 ജൂൺ മാസത്തിൽ പുറത്തിറങ്ങി, എന്നിരുന്നാലും 2012-ൽ അത് ഔദ്യോഗികമായി ഉപേക്ഷിക്കപ്പെട്ടു.

സ്കാലയിൽ എഴുതിയിരിക്കുന്ന ഹലോ വേൾഡ് പ്രോഗ്രാം

 object HelloWorld extends App {
   println("Hello, World!")
 }

ജാവക്കുള്ള സ്റ്റാൻഡ്-എലോൺ (ആരുടെയും സഹായം കൂടാതെ തനിയെ പ്രവർത്തിക്കാൻ കഴിവുള്ള യൂണിറ്റ്‌) ഹലോ വേൾഡ് ആപ്ലിക്കേഷനിൽ നിന്ന് വ്യത്യസ്തമായി, ക്ലാസ് ഡിക്ലറേഷൻ ഇല്ല, ഒന്നും സ്റ്റാറ്റിക് ആയി പ്രഖ്യാപിച്ചിട്ടില്ല. പകരം ഒബ്ജക്റ്റ് കീവേർഡിൽ ഉപയോഗിച്ചിരിക്കുന്ന സിംഗിൾടൺ വസ്തുവാണ് ഉപയോഗിക്കുന്നത്. പ്രോഗ്രാം HelloWorld.scala -ൽ സൂക്ഷിക്കുമ്പോൾ, ആ കമാൻഡ് ഉപയോഗിച്ച് ഉപയോക്താവ് അത് മെഷീൻ കോഡിലേക്ക്‌ കമ്പ്യൂട്ടർ പ്രോഗ്രാം മാറ്റുന്നു.

$ scalac HelloWorld.scala

ഒപ്പം ഇത് പ്രവർത്തിപ്പിക്കുന്നു

$ scala HelloWorld

സ്കാലയുടെ കംപൈൽ ചെയ്യൽ, നിർവഹിക്കുന്ന മാതൃക എന്നിവ ജാവയുടെതിന് സമാനമാണ്, ഇത് അപ്പാച്ചെ ആൻറ് പോലുള്ള ജാവ ബിൽഡ് ടൂളുകളുമായി പൊരുത്തപ്പെടുന്നു.

"ഹലോ വേൾഡ്" സ്കാല പ്രോഗ്രാമിൻറെ ഒരു ഹ്രസ്വ പതിപ്പ് ചുവടെ ചേർത്തിരിക്കുന്നു:

println("Hello, World!")

സ്കാലയിൽ അന്യോന്യം സമ്പർക്കം പുലർത്തുന്ന ഷെൽ, സ്ക്രിപ്റ്റിങ് പിന്തുണ എന്നിവ ഉൾപ്പെടുന്നു. HelloWorld2.scala എന്ന പേരിൽ ഒരു ഫയൽ സൂക്ഷിച്ച്, ഇത് മുൻകൂർ കംപൈൽ ചെയ്യാത്ത ഒരു സ്ക്രിപ്റ്റ് ആയി റൺ ചെയ്യാൻ കഴിയും:

$ scala HelloWorld2.scala

ഓപ്ഷൻ -e ഉപയോഗിച്ച് കമാൻഡുകൾ നേരിട്ട് സ്കാല ഇൻറർപ്രെട്ടറിൽ പ്രവേശിക്കാം:

$ scala -e 'println("Hello, World!")'

REPL ൽ എക്സ്പ്രഷനുകളെ പരസ്പരം ചേർക്കാം:

$ scala
Welcome to Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131).
Type in expressions for evaluation. Or try :help.

scala> List(1, 2, 3).map(x => x * x)
res0: List[Int] = List(1, 4, 9)

scala>

താഴെക്കാണുന്ന ഉദാഹരണം ജാവ, സ്കാല പ്രോഗ്രാമിംഗിലുള്ള നിർദ്ദേശങ്ങളുടെ പൊതുവായ ഘടന (syntax) എന്നിവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ കാണിക്കുന്നു:

// Java:
int mathFunction(int num) {
    int numSquare = num*num;
    return (int) (Math.cbrt(numSquare) +
      Math.log(numSquare));
}

// Scala: Direct conversion from Java

// no import needed; scala.math
// already imported as `math`
def mathFunction(num: Int): Int = {
  var numSquare: Int = num*num
  return (math.cbrt(numSquare) + math.log(numSquare)).
    asInstanceOf[Int]
}

// Scala: More idiomatic
// Uses type inference, omits `return` statement,
// uses `toInt` method, declares numSquare immutable

import math._
def mathFunction(num: Int) = {
  val numSquare = num*num
  (cbrt(numSquare) + log(numSquare)).toInt
}

ഈ കോഡിലെ ചില പ്രോഗ്രാമിംഗിലുള്ള നിർദ്ദേശങ്ങളുടെ പൊതുവായ ഘടന വ്യത്യാസങ്ങൾ ഇവയാണ്:

• സ്കാല പ്രസ്താവനകൾ അവസാനിപ്പിക്കാൻ അർദ്ധവിരാമങ്ങൾ(;) ആവശ്യമില്ല.
• int, double, boolean എന്നതിനു പകരമായി മൂല്യ തരങ്ങൾ വലിയ അക്ഷരങ്ങളിലെഴുതിയിരിക്കുന്നു: Int, Double, Boolean .
• സി (പ്രോഗ്രാമിങ് ഭാഷ) മുമ്പേ ഉണ്ടായിരുന്നതിന് പകരം പാസ്കൽ പോലെയുള്ള, പാരാമീറ്റർ, റിട്ടേൺ തരങ്ങൾ എന്നിവ പിന്തുടരുന്നു.
• defഎന്ന മെത്തേഡ് ഉണ്ടായിരിക്കണം.
• ലോക്കൽ അല്ലെങ്കിൽ ക്ലാസ് വേരിയബിൾ ഉണ്ടായിരിക്കണം val ( immutable നെ സൂചിപ്പിക്കുന്ന ഒരു വേരിയബിൾ) അല്ലെങ്കിൽ var (mutable നെ സൂചിപ്പിക്കുന്ന ഒരു വേരിയബിൾ).
• ഒരു return ഫങ്ഷനിൽ ഓപ്പറേറ്റർ അനാവശ്യമാണ് (അനുവദിച്ചെങ്കിലും); നിർവഹിച്ചു കഴിഞ്ഞ പ്രസ്താവനയുടെയോ എക്സ്പ്രഷൻറെയോ മൂല്യം സാധാരണയായി ഫങ്ഷൻറെ മൂല്യം ആണ്.
• ജാവ കാസ്റ്റ് ഓപ്പറേറ്റർക്ക് പകരം (Type) foo, സ്കാല ഉപയോഗിക്കുന്നു

foo.asInstanceOf [Type], അല്ലെങ്കിൽ ഒരു പ്രത്യേക ഫങ്ഷൻ toDouble അല്ലെങ്കിൽ toInt.

• ജാവ ഉപയോഗിക്കുന്നimport foo.*;എന്നതിന് പകരമായി സ്കാല import foo._.ഇത് ഉപയോഗിക്കുന്നു.
• ഫങ്ഷൻ അല്ലെങ്കിൽ രീതി foo () എന്നതിനെ foo എന്നും വിളിക്കാം; method thread.send (signo) എന്നതിന് thread send signo; എന്ന് മാത്രമേ വിളിക്കാവൂ; കൂടാതെ foo.toString () എന്ന രീതിയും foo toString ആയിരിക്കണം.

ഡൊമെയിൻ സവിശേഷ ഭാഷ കൾക്കുള്ള പിന്തുണ അനുവദിക്കുന്നതിനായാണ് ഈ വാക്യഘടനാപരമായ മാറ്റങ്ങൾ രൂപകല്പന ചെയതത്.

മറ്റ് ചില അടിസ്ഥാന വാക്യഘടനകൾ:

• അറേ റഫറൻസുകൾ ഫംഗ്ഷൻ കോളുകൾ പോലെ എഴുതുന്നു, ഉദാ. array [i] എന്നതിനേക്കാൾ array(i) . (ആന്തരികമായി സ്കാലയിൽ, അറേകളും പ്രവർത്തനങ്ങളും ഒരു വസ്തുവിൽ നിന്ന് മറ്റൊന്നിൽ നിന്ന് ഗണിത മാപ്പിംഗുകൾ ആയി കണക്കാക്കപ്പെടുന്നു.)
• പൊതുവായ തരങ്ങൾ എഴുതിയത് വ്യത്യസ്തമാണ്. ഉദാഹരണം. ജാവയുടെList<String> എന്നതിനു പകരം List[String].
• void, എന്ന സൂഡോ (pseudo-type) തരത്തിന് പകരം സ്കാലക്ക് Unit സിങ്കിൾട്ടൺ തരം ഉണ്ട്.(താഴെ നോക്കുക).

താഴെക്കാണുന്ന ഉദാഹരണം ജാവ, സ്കലാ വിഭാഗങ്ങളിലെ നിർവചനത്തെക്കുറിച്ച് താരതമ്യപഠനം നടത്തുന്നു.

// Java:
public class Point {
  private final double x, y;

  public Point(final double x, final double y) {
    this.x = x;
    this.y = y;
  }

  public Point(
    final double x, final double y,
    final boolean addToGrid
  ) {
    this(x, y);

    if (addToGrid)
      grid.add(this);
  }

  public Point() {
    this(0.0, 0.0);
  }

  public double getX() {
    return x;
  }

  public double getY() {
    return y;
  }

  double distanceToPoint(final Point other) {
    return distanceBetweenPoints(x, y,
      other.x, other.y);
  }

  private static Grid grid = new Grid();

  static double distanceBetweenPoints(
      final double x1, final double y1,
      final double x2, final double y2
  ) {
    return Math.hypot(x1 - x2, y1 - y2);
  }
}

// Scala
class Point(
    val x: Double, val y: Double,
    addToGrid: Boolean = false
) {
  import Point._

  if (addToGrid)
    grid.add(this)

  def this() = this(0.0, 0.0)

  def distanceToPoint(other: Point) =
    distanceBetweenPoints(x, y, other.x, other.y)
}

object Point {
  private val grid = new Grid()

  def distanceBetweenPoints(x1: Double, y1: Double,
      x2: Double, y2: Double) = {
    math.hypot(x1 - x2, y1 - y2)
  }
}

മുകളിലുള്ള കോഡ് ജാവ, സ്കാല ക്ലാസുകൾ കൈകാര്യം ചെയ്യുന്ന ആശയപരമായ വ്യത്യാസങ്ങൾ കാണിക്കുന്നു:

• സ്കാലക്ക് സ്റ്റാറ്റിക് വേരിയബിളുകളോ രീതികളോ ഇല്ല. ഇതിനു പകരം, "ഒറ്റപ്പാലക വസ്തുക്കൾ (singleton)" ഉണ്ട്, അവ പ്രത്യേകിച്ചും ക്ലാസിലുള്ള ഒരു വസ്തുവുമായുള്ളതാണ്. class ന് പകരമായി സിംഗിൾടൺ വസ്തുക്കൾ object ഉപയോഗിച്ച് പ്രസ്‌താവിച്ചു. സ്റ്റാറ്റിക് വേരിയബിളും സ്റ്റാൻഡേർഡ് വേരിയബിളും ഒരു ഏകീകൃത ഓബ്ജറ്റിലെ ക്ലാസ് നെയിം ഉപയോഗിച്ച അതേ പേരിലാണ് ഇതിനെ വിളിക്കുന്നത്. അത് പിന്നീട് സഹചാരി വസ്തു (companion object) എന്നറിയപ്പെട്ടു. (സിങ്കിൾട്ടൺ ഒബ്ജക്റ്റിനുള്ള അടിത്തറ ഒരു $ കൂട്ടിച്ചേർത്തു, അതിനാൽ, class Foo object Foo എന്ന പേരിൽ, സഹചാരി വസ്തുവിൻറെ കോഡ് ഉൾക്കൊള്ളുന്ന ക്ലാസ് Foo$ , ഈ ഏക പാറ്റേൺ ഉപയോഗിച്ച് ഈ ക്ലാസ് ഒരു വസ്തു സൃഷ്ടിക്കും.)
• കൺസ്ട്രക്ടർ പാരാമീറ്ററുകൾക്ക് പകരം, സ്കാലക്ക് ക്ലാസ് വില നൽകിയിരിക്കുന്ന ക്ലാസ് പാരാമീറ്ററുകൾ ഉണ്ട്. ഒരു val അല്ലെങ്കിൽ var പരിഷ്കർത്താവ്(modifier) ഉപയോഗിച്ച് നിർവചിക്കുമ്പോൾ, പ്രവർത്തനതലങ്ങളും ഇതേ പേരിൽ തന്നെയാണ് നിർവ്വചിക്കപ്പെട്ടിരിക്കുന്നത്, ഒപ്പം ക്ലാസ് പാരാമീറ്ററുകളിൽ നിന്ന് സ്വയം ആരംഭിക്കും.(വികസനത്തിൽ, പൊതു പ്രവർത്തനതലത്തേക്ക് പുറമെയുള്ള പ്രവേശനം എല്ലായ്പ്പോഴും ആക്സസ്സർ (ഗെറ്റർ), സ്വപ്രേരിതമായി സൃഷ്ടിക്കുന്ന മ്യൂട്ടേറ്റർ (സെറ്റർ) രീതികളിലൂടെ കടന്നുപോവുന്നു. ആക്സസ്സർ നിർവഹണ പ്രവർത്തനതലത്തിന് സമാനമായ പേര് ആണ്, അതിനാൽ ഇത് അക്സസർ രീതികൾ വ്യക്തമായി പ്രഖ്യാപിക്കുന്നതിനായി മുകളിൽ പറഞ്ഞ ഉദാഹരണത്തിൽ അത് അനാവശ്യമാണ്.) ജാവയിലെ പോലെ, ബദൽ നിർമ്മാതാക്കളെ പ്രഖ്യാപിക്കാനാകും. സ്ഥിരസ്ഥിതി കൺസ്ട്രക്റ്ററിലേക്ക് പോകേണ്ട കോഡ് (അംഗം വേരിയബിളുകൾ ആരംഭിക്കുന്നതിനു പകരം) ക്ലാസ് തലത്തിൽ നേരിട്ട് പ്രവർത്തിക്കുന്നു.
• സ്കാലയിലെ സ്ഥിര ദൃശ്യത public ആകുന്നു.

സ്കാലയ്ക്ക് സമാനമായ കമ്പൈലിങ് മാതൃക ജാവയും സി ഷാർപ് (C#) ഉം ആണ്, അതായത് പ്രത്യേക കമ്പൈലിങ്, ഡൈനാമിക് ക്ലാസ് ലോഡിങ് എന്നിവ. അതിനാൽ സ്കാല കോഡിന് ജാവ ലൈബ്രറികൾ വിളിക്കാൻ കഴിയും.

സ്കാലയുടെ പ്രവർത്തന സവിശേഷതകൾ ജാവയുടെതിന് സമാനമാണ്. സ്കാല കമ്പൈലർ, ജാവ കമ്പൈലർ നിർമ്മിച്ചതിന് സമാനമായ ബൈറ്റ് കോഡ് നിർമ്മിക്കുന്നു. വാസ്തവത്തിൽ, സ്കാല കോഡ്, ജാവ കോഡിലേക്ക് വായിക്കാൻ സാധിക്കുന്ന വിധത്തിൽ വേർതിരിച്ചെടുക്കാൻ (decompile) കഴിയും. ചില കൺസ്ട്രക്ടർ പ്രവർത്തനങ്ങൾ ഒഴികെ. ജാവ അയഥാർത്ഥ യന്ത്രത്തിന് (വെർച്ച്വൽ മെഷീൻ (ജെവിഎം)), സ്കാല കോഡ്, ജാവാ കോഡ് എന്നിവ തിരിച്ചറിയാൻ പറ്റാത്തവയാണ്. ഒരു അധിക റൺടൈം ലൈബ്രറി വ്യത്യാസം മാത്രമാണ് ഉള്ളത്, scala-library.jar.

ജാവയുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ സ്കാല ലളിതമായ നിരവധി പ്രത്യേകതകൾ ചേർക്കുന്നു, അതിൻറെ എക്സ്പ്രഷൻ, തരം എന്നിവയിൽ അടിസ്ഥാനപരമായ വ്യത്യാസങ്ങൾ അടങ്ങിയിരിക്കുന്നു, ജാവയിലെ പല കോണുകളായും ഭാഷ സിദ്ധാന്തം വൃത്തിയാക്കുന്നു, അവ നീക്കം ചെയ്യുന്നു. സ്കാല കാഴ്ചപ്പാടിൽ, ഇത് പ്രാധാന്യമർഹിക്കുന്നതാണ്, കാരണം സ്കാലയിലെ നിരവധി കൂട്ടിചേർത്ത സവിശേഷതകൾ സി ഷാർപിലും (C#) ലഭ്യമാണ്.