കോട്‌ലിൻ (പ്രോഗ്രാമിങ് ഭാഷ)

**കോട്ലിൻ** എന്നത് ക്രോസ് പ്ലാറ്റ്ഫോമാണ്, സ്റ്റാറ്റിസ്റ്റിക്കൽ ടൈപ്പ് ചെയ്ത, ടൈപ്പ് അനുമാനത്തോട് കൂടിയ പൊതു-ഉദ്ദേശ പ്രോഗ്രാമിങ് ഭാഷയാണ്. ജാവയിൽ പൂർണ്ണമായും പരസ്പരപ്രവർത്തനക്ഷമതയോട് കൂടി രൂപകൽപ്പന ചെയ്തിരിക്കുന്ന കോട്ലിൻ, ജാവാ ലൈബ്രറിയെ ആശ്രയിച്ചുകൊണ്ട് അതിന്റെ അടിസ്ഥാന ലൈബ്രറിയുടെ ജെവിഎം(JVM) പതിപ്പാണിത് ,എന്നാൽ ടൈപ്പ് അനുമാനം അതിന്റെ വാക്യഘടന കൂടുതൽ സംക്ഷിപ്തമാക്കുന്നു. കോട്ലിൻ പ്രധാനമായും ജെവിഎം ലക്ഷ്യമാക്കുന്നു, കൂടാതെ ജാവാസ്ക്രിപ്റ്റ് അല്ലെങ്കിൽ നേറ്റീവ് കോഡ് (എൽ എൽ വി എം വഴി) ചേർക്കുന്നു. കോട്ലിൻ ഫൗണ്ടേഷനിലൂടെ ജെറ്റ്ബ്രെയിൻസും ഗൂഗിളും ആണ് കോട്ലിനെ സ്പോൺസർ ചെയ്യുന്നത്.

ആൻഡ്രോയിഡ് മൊബൈൽ വികസനത്തിനായി ഗൂഗിൾ കോട്ലിൻ ഔദ്യോഗികമായി പിന്തുണയ്ക്കുന്നു. 2017 ഒക്ടോബറിൽ ആൻഡ്രോയ്ഡ് സ്റ്റുഡിയോ 3.0 പുറത്തിറങ്ങിയതിനു ശേഷം, കോട്ലിൻ സ്റ്റാൻഡേർഡ് ജാവ കമ്പൈലറിന് ബദലായി ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ആൻഡ്രോയ്ഡ് ടാർഗെറ്റുചെയ്യുന്ന ജാവാ 6 അല്ലെങ്കിൽ ജാവാ 8 അനുയോജ്യമായ ബൈറ്റ്കോഡ് തിരഞ്ഞെടുക്കുന്നതിന് കോട്ലിൻ കമ്പൈലർ ഉപയോക്താവിനെ അനുവദിക്കുന്നു.

## ചരിത്രം
2011 ജൂലൈയിൽ, ജെറ്റ് ബ്രെയ്ൻസ്, ഒരു വർഷത്തേയ്ക്ക് വികസിപ്പിച്ചുകൊണ്ടിരുന്ന ജെവിഎം പ്രോജക്ടിനായുള്ള കോട്ലിൻ എന്ന പുതിയ ഭാഷ അനാച്ഛാദനം ചെയ്തു.സ്കാല ഒഴികെയുള്ള മിക്ക ഭാഷകളിലും അവർ തിരയുന്ന സവിശേഷതകളില്ലെന്ന് ജെറ്റ് ബ്രെയ്ൻസിന് നേതൃത്വം വഹിക്കുന്ന ദിമിത്രി ജെമെറോവ് പറഞ്ഞു. എന്നിരുന്നാലും, സ്കാലയുടെ  കംപൈലേഷൻ സമയം അപര്യാപ്തത അദ്ദേഹം ചൂണ്ടിക്കാട്ടി.കോട്ലിൻ പറഞ്ഞ ലക്ഷ്യങ്ങളിൽ ഒന്ന് അതിവേഗം ജാവയെ സമാഹരിക്കുന്നതിനാണ്(compile). 2012 ഫെബ്രുവരിയിൽ, അപ്പാച്ചെ 2 ലൈസൻസിനു കീഴിൽ ജെറ്റ്ബ്രെയിൻ തുറന്ന ഉറവിടമായി പ്രഖ്യാപിച്ചു.

സെന്റ് പീറ്റേർസ്ബർഗിനടുത്തുള്ള കോട്ലിൻ ദ്വീപിൽ നിന്നാണ് ഈ പേര് വരുന്നത്. ഇന്തോനേഷ്യയിലെ ജാവയെ പോലെയുള്ള ഈ ദ്വീപിന്റെ നാമം നൽകാൻ തീരുമാനിച്ചതായി ആന്ദ്രേ ബ്രെസ്ലാവ് സൂചിപ്പിച്ചു (പ്രോഗ്രാമിങ് ഭാഷയിൽ ജാവ എന്ന പേര് നൽകപ്പെട്ടത് കോഫീ എന്ന നാമത്തിന് ശേഷമായിരിക്കാം).

ജെറ്റ് ബ്രെയ്ൻസിന്റെ ഈ പുതിയ ഭാഷ ഇന്റലിജെ ഐഡിയടൊപ്പം(IntelliJ IDEA) വിൽപ്പനക്ക് വിനിയോഗിക്കാൻ കഴിയുമെന്ന് പ്രതീക്ഷിക്കുന്നു.

2016 ഫെബ്രുവരി 15 ന് കോട്ലിൻ v1.0 പുറത്തിറങ്ങി.ഇത് ആദ്യ ഔദ്യോഗിക സ്ഥിരമായ റിലീസായി കണക്കാക്കപ്പെടുന്നു, കൂടാതെ ജെറ്റ്ബ്രേയിൻസ്(JetBrains) ഈ പതിപ്പിനെത്തുടർന്ന് ദീർഘകാലത്തെ പിന്നോട്ടുള്ള അനുയോജ്യതയിൽ(backward compatibility) പ്രതിജ്ഞാബദ്ധമാണ്.

ഗൂഗിൾ I / O 2017 ൽ, ആൻഡ്രോയിഡിൽ കോട്ലിനായുള്ള ഫസ്റ്റ് ക്ലാസ് പിന്തുണ ഗൂഗിൾ പ്രഖ്യാപിച്ചു.

2017 നവംബർ 28 ന് കോട്ലിൻ v1.2 പുറത്തിറങ്ങി.ജെവിഎം, ജാവാസ്ക്രിപ്റ്റ് പ്ലാറ്റ്ഫോമുകൾ തമ്മിലുള്ള പങ്കിടൽ കോഡ് ഈ റിലീസിലേക്ക് പുതുതായി ചേർത്തിരിക്കുന്നു. 2018 ഒക്ടോബറിൽ കോട്ലിൻ v1.3 പുറത്തിറങ്ങി, അസിൻക്രണസ് പ്രോഗ്രാമിനായി കോറുട്ടീനുകൾ (coroutines)കൊണ്ടുവന്നു.

## ഡിസൈൻ
കോട്ലിൻ ഒരു വ്യാവസായിക ശക്തിയുള്ള ഒബ്ജക്റ്റ്-ഓറിയെന്റഡ് ഭാഷയായി രൂപകൽപ്പന ചെയ്തിട്ടുണ്ടെന്ന് വികസത്തിന് നേതൃത്വം വഹിക്കുന്ന ആന്ദ്രേ ബ്രെസ്ലാവ് പറഞ്ഞു. ജാവയെ അപേക്ഷിച്ച് "മികച്ച ഭാഷ", എന്നാൽ ഇപ്പോഴും ജാവ കോഡിനൊപ്പം പൂർണ്ണമായും പരസ്പരം പ്രവർത്തിക്കുന്നു, ജാവയിൽ നിന്നും കോട്ലിനിലേക്ക് ക്രമാനുഗതമായ കുടിയേറ്റം നടത്താൻ കമ്പനികളെ അനുവദിക്കുന്നു.

ഒരു പ്രസ്താവനയുടെ അന്ത്യം കുറിക്കുന്ന അർദ്ധവിരാമം ഇച്ഛാനുസൃതമാണ്; മിക്ക കേസുകളിലും കമ്പൈലർ പ്രസ്താവന അവസാനിപ്പിച്ചതായി മനസ്സിലാക്കാൻ ഒരു പുതിയ വരി മതിയാകും.

പാസ്കലുമായി സാമ്യമുള്ള വ്യത്യാസത്തിനു ശേഷം കോട്ലിൻ ചര പ്രസ്താവനകളും പാരാമീറ്റർ ലിസ്റ്റുകളും ഡാറ്റ തരത്തെ നൽകുന്നു (കൂടാതെ ഒരു അപൂർണ്ണവിരമാത്തെ വേർതിരിക്കാൻ സാധിക്കുന്നു). കോട്ലിനിൽ ഉപയോഗിക്കുന്ന ചരങ്ങൾ മാറ്റമില്ലാത്തതാണ്,`val` എന്ന സൂചകപദം, അല്ലെങ്കിൽ മാറ്റമുള്ള, `var`സൂചകപദം ഉപയോഗിച്ച് പ്രസ്താവിക്കുന്നു.

ക്ലാസ് അംഗങ്ങൾ സ്വതേ പബ്ലിക്കാണ്, ക്ലാസുകൾ സ്വതേ തന്നെ അന്തിമമാണ്, അതായത് ഒരു ഡെറീവേഡ് ക്ലാസ്സ് ഉണ്ടാക്കുന്നത് അപ്രാപ്തമാക്കിയിരിക്കുകയാണ് തുറന്ന കീവേഡ് ഉപയോഗിച്ച് അടിസ്ഥാന ക്ലാസ്സ് പ്രഖ്യാപിക്കപ്പെടുന്നില്ലെങ്കിൽ.

ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിങ്ങിന്റെ ക്ലാസുകളും രീതികളും (കോട്ലിൻ അംഗത്വ പ്രവർത്തനം)കോട്ലിൻ ഫങ്ഷനുകൾ ഉപയോഗിച്ചു കൊണ്ട് പ്രോസീജറൽ പ്രോഗ്രാമിംഗിനെ പിന്തുണയ്ക്കുന്നു.

കോട്ലിൻ ഫംഗ്ഷനുകളും (കൺസ്ട്രറ്റേഴ്സ്) സ്ഥിരസ്ഥിതി ആർഗ്യുമെന്റുകൾ, വേരിയബിൾ-ദൈർഘ്യ ആർഗ്യുമെന്റ് ലിസ്റ്റുകൾ, നാമ ആർഗ്യുമെന്റുകൾ, ഓവർലോഡിംഗ് എന്നിവയെ സവിശേഷ സിഗ്നേച്ചർ ഉപയോഗിച്ച് പിന്തുണയ്ക്കുന്നു. ക്ലാസ് മെമ്പർ പ്രവർത്തനങ്ങൾ അയഥാർത്ഥമാണ്(virtual), അതായത് അവർ വിളിക്കപ്പെടുന്ന വസ്തുവിന്റെ റൺടൈം തരം അടിസ്ഥാനമാക്കിയുള്ളതാണ്.
## വാക്യഘടനകൾ
### ഫങ്ഷണൽ പ്രോഗ്രാമിങ് ശൈലി
സ്റ്റാറ്റിക് രീതികളും വേരിയബിളും ഒരു ക്ലാസ് ബോഡിക്കുള്ളിൽ മാത്രം നിലനിൽക്കാൻ അനുവദിക്കുന്ന ജാവയുടെ നിയന്ത്രണം കോട്ലിൻ പാലിക്കുന്നു. ഒരു ആവർത്തന ക്ലാസ് നില ആവശ്യമില്ലാതെ തന്നെ പാക്കേജിന്റെ ഉയർന്ന തലത്തിൽ സ്റ്റാറ്റിക് ഒബ്ജക്റ്റുകളും ഫംഗ്ഷനുകളും നിർവചിക്കാവുന്നതാണ്. ജാവയുടെ അനുയോജ്യതയ്ക്കായി കോട്ലിൻ ഒരു `JvmName` വ്യാഖ്യാനം നൽകുന്നു, ഇത് ജാവ പ്രോജക്ടിൽ നിന്ന് പാക്കേജ് കണ്ടപ്പോൾ ഉപയോഗിക്കുന്ന ഒരു ക്ലാസ് നാമം വ്യക്തമാക്കുന്നു.ഉദാഹരണത്തിന്, `@file: JvmName ("JavaClassName").`
### പ്രധാന എൻട്രി പോയിന്റ്
സി, സി++ എന്നിവ പോലെ ഒരു കോട്ലിൻ പ്രോഗ്രാം പ്രവേശന പോയിന്റ് "main" എന്ന പേരിൽ ഉള്ള ഒരു ഫങ്ഷൻ ആണ്. കമാന്റ് ലൈൻ ആർഗ്യുമെന്റുകൾ അടങ്ങുന്ന ഒരു അറേയാണ് ഇത് വിതരണം ചെയ്യുന്നത്. പേൾ, യൂണിക്സ് ഷെൽ ശൈലി സ്ട്രിംഗ് ഇന്റർപോളേഷൻ പിന്തുണയ്ക്കുന്നു. ടൈപ്പുചെയ്യൽ അനുമാനവും പിന്തുണയ്ക്കും.

```kotlin
// Hello, World! example
fun main(args: Array<String>) {
  val scope = "World"
  println("Hello, $scope!")
}
```

### വിപുലീകരണ രീതികൾ
പുതിയ രീതികളുമുണ്ടായ ഒരു ഡെറിവേഡ് ക്ലാസ് സൃഷ്ടിക്കുന്ന സമ്പ്രദായങ്ങൾ ഇല്ലാതെ ഏതെങ്കിലും ക്ലാസിലേക്ക് സി# പോലെ തന്നെ കോട്ലിൻ ഉപയോക്താവിന് രീതികൾ ചേർക്കാൻ അനുവദിക്കുന്നു. പകരം, ക്ലാസ്സിന്റെ ഇടപെടലില്ലാതെ ഒരു വർഗ്ഗത്തിന്റെ പൊതു സമ്പ്രദായ പട്ടികയിലേയ്ക്ക് "ഗ്ലൂഡ്" ചെയ്യേണ്ട ഒരു വിപുലീകരണ രീതി എന്ന ആശയം കോട്ലിൻ ചേർക്കുന്നു. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു വിപുലീകരണ രീതി ഒരു സഹായ സംവിധാനമാണ്, അത് ഒരു ക്ലാസിലെ എല്ലാ പൊതു ഇന്റർഫേസിലേക്കും പ്രവേശനം ഉണ്ടായിരിക്കും, ഒരു ടാർഗെറ്റ് ശൈലിയിൽ ഒരു പുതിയ രീതിയിലുള്ള ഇന്റർഫേസ് സൃഷ്ടിക്കാൻ ഇത് ഉപയോഗിക്കാം, ഈ രീതി ക്ലാസിലെ ഒരു രീതി പോലെ തന്നെ ദൃശ്യമാകും, ക്ലാസ് രീതികളുടെ കോഡ് പരിശോധനയുടെ ഭാഗമായി പ്രത്യക്ഷപ്പെട്ടു. ഉദാഹരണത്തിന്:

```kotlin
package MyStringExtensions

    fun String.lastChar(): Char = get(length - 1)

    >>> println("Kotlin".lastChar())
```

ഒരു പാക്കേജിന്റെ ഉന്നത-തലത്തിലുള്ള, മുമ്പുള്ള കോഡ് നല്കുന്നതിലൂടെ സ്ട്രിങ് ക്ലാസിൽ ഒരു `lastChar` രീതി ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, അത് സ്ട്രിങ് ക്ലാസിന്റെ ഒറിജിനൽ ഡെഫനിഷനിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല.

```kotlin
// Overloading '+' operator using an extension method
    operator fun Point.plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }

    >>> val p1 = Point(10, 20)
    >>> val p2 = Point(30, 40)
    >>> println(p1 + p2)
    Point(x=40, y=60)
```


## അവലംബം