|  |  |
| --- | --- |
|  | სხვა მნიშვნელობებისთვის იხილეთ **ჯავა (მრავალმნიშვნელოვანი)**. |

*არ აგერიოთ ერთმანეთში ჯავა და ჯავასკრიპტი*
**ჯავა** (ინგლ. Java წარმოითქმის,  **/dʒɑːvə/**) არის ზოგადი დანიშნულების, კონკურენტული, ობიექტურად ორიენტირებული პროგრამირების ენა. Java არის მკაცრად (სტატიკურად) ტიპიზირებული ენა. სინტაქსური აგებულებით ის წააგავს უფრო ადრეულ ენებს C და C++. მისი ობიექტური მოდელი აგრეთვე მნიშვნელოვნად ნასესხებია C++ და Smalltalk ენებიდან. Java პროგრამები კომპილირდება ბაიტ-კოდებში და ეშვება Java ვირტულურ მანქანაში (JVM), რაც უზრუნველყოფს კომპილირებული პროგრამის დამოუკიდებლობას გამშვები სისტემასთან მიმართებაში.

ოფიციალურად Java 1995 წლის 23 მაისს გამოვიდა. Java-ს პირველადი შემუშავება ეკუთვნის Sun Microsystems, რომელიც დღემდე რჩება Java ვირტუალური მანქანის და ენის სპეციფიკაციის ძირითად განმსაზღვრელად.

Java მხარდაჭერილია ძირითად კომპიუტერულ და მობილურ ოპერაციულ სისტემებში, უამრავ საყოფაცხოვრებო და ციფრული მოწყობილობაში, აგრეთვე საბანკო პლასტიკურ და სხვა სახის სერვის ბარათებში.

დღეს Java ყველაზე გავრცელებული ენაა, მოწყობილობათა რაოდენობის მიხედვით, რომლებიც ასრულებენ Java პროგრამებს და, აგრეთვე, ყველაზე პოპულარული ენაა იმ პროგრამისტების რაოდენობის მიხედვით, რომლებიც წერენ თავის პროგრამებს Java-ზე.

ისტორია
-------

Java-ს პერსონაჟი Duke, რომელიც პირველად Star7 მოწყობილობაზე გამოჩნდა
Java-ს ისტორია იწყება 1990 წლის დეკემბრიდან, როდესაც Sun Microsystems-ში მცირე ჯგუფის მიერ ინიცირებულია „მწვანე პროექტი" (Green Project). ამ პროექტის მიზანი იყო სამომხმარებლო ციფრული მოწყობილობების დაპროგრამების შესაძლებლობა, ისევე როგორც ეს კომპიუტერებზე შეიძლებოდა.

მწვანე პროექტის ფარგლებში ჯეიმზ გოსლინგის მიერ შეიქმნა ახალი პროგრამირების ენა Oak, რომელიც არ იყო დამოკიდებული კონკრეტული მოწყობილობის აგებულების დეტალებზე. Oak შემდგომში სახელი შეუცვალეს, და მას Java დაერქვა.

Star7 მოწყობილობის წარმატებული დემონსტრაციის შემდეგ 1993 წელს „მწვანე პროექტი" First Person Inc.-ში გადადის, რომელსაც სრულად აფინანსებს Sun.

First Person Inc. საბოლოო ჯამში დაიხურა როგორც არაპერსპექტიული იმ დროისათვის. თუმცა აღმოაჩნდა, რომ ის პრობლემები, რომლების გადაჭრასაც ცდილობდნენ ამ პროექტში, აგრეთვე აქტუალურად იდგა სხვა სწრაფადგანვითარებად დარგში — ინტერნეტში.

განცხადება Java ალფა ვერსიის გამოსვლის შესახებ გაკეთდა 1995 წლის 23 მაისს, Sun World კონფერენციაზე. საბოლო ვერსიით JDK 1.0 (Java Development Kit) გამოვიდა 1996 წელს.

პირველი ფართო აღიარება Java ტექნოლოგიამ მიიღო 1997 წელს, როდესაც გამოვიდა JDK-ს შემდეგი, 1.1, ვერსია.

Java-ს ვერსიები შემდეგი ქრონოლოგიით გამოდიოდა:

**JDK 1.0**, 1996 წლის 23 იანვარი.

**JDK 1.1**, 1997 წლის 19 თებერვალი. სიახლეები შეიცავდა AWT ბიბლიოთეკის გაუმჯობესებას, ახალ JDBC ტექნოლოგიას რელაციურ მონაცემთა ბაზებთან სამუშაოდ და JavaBean პროგრამირების ინტერფეისს. აგრეთვე მნიშვნელოვანი იყო Unicode სტანდარტის მხარდაჭერის გამოჩენა.

**J2SE 1.2**, 1998 წლის 8 დეკემბერი. პირველად გამოჩნდა Swing ბიბლიოთეკა მომხმარებლის ინტერფეისის გაუმჯობესებული მხარდაჭერით, შედარებით უფრო ადრეულ AWT-თან.

**J2SE 1.3**, 2000 წლის 8 მაისი. გაზრდილი წარმადობა. RMI/IIOP და JNDI ტექნოლოგიები.

**J2SE 1.4**, 2002 წლის 6 თებერვალი. 64 ბიტიანი არქიტექტურის მხარდაჭერა, XML დამუშავების ჩადგმული შესაძლებლობები.

**J2SE 5.0**, 2004 წლის 30 სექტემბერი. ენის ახალი კონსტრუქციები, როგორიცაა კლასის პარამეტრები (Generics), for ციკლის გაფართოებული შესაძლებლობები, პრიმიტიული ტიპების ავტომატური კონვერტაცია შესაბამის ობიექტურ ტიპებში და პირიქით, უტიპო Enum, ცვლადი არგუმენტების სია ფუნქციაში, სტატიკური import და მეტამონაცემების, ანუ ანოტაციების მხარდაჭერა.

**Java SE 6.0**, 2006 წლის 11 დეკემბერი. სხვა უამრავ სიახლეებს შორისაა ჩადგმული მონაცემთა ბაზა Java DB, გრაფიკული ინტერფეისის გაფართოებული შესაძლებლობები, სკრიპტული ენების მხარდაჭერა და კომპილატორთან პროგრამულად მუშაობის შესაძლებლობა.

ძირითადი თავისებურებები
-----------------------

### შესრულების გარემოსგან დამოუკიდებლობა

Java-ს ძირითადი მახასიათებელი თვისებაა იყოს დამოუკიდებელი შესრულების გარემოს აგებულების დეტალებისაგან; Java პლატფორმის ყველაზე ცნობილი დაპირების, *დაწერე ერთხელ, გაუშვი ყველგან*, შესაბამისად. ასეთი მიდგომა უპირველეს ყოვლისა ამარტივებს პროგრამის შემქმნელის შრომას, რადგან, ვთქვათ Mac OS X ოპერაციულ სისტემაში დაწერილი პროგრამა შესაძლებელია ცვლილების გარეშე გადავიტანოთ სხვა, მაგალითად, Linux ოპერაციული სისტემაში.

ცნება *შესრულების გარემო* Java-ს შემთხვევაში გაცილებით შორსაა წასული ვიდრე უბრალოდ ოპერაციული სისტემა. ასე მაგალითად, ამოსაბეჭდი მოწყობილობა აგრეთვე შესრულების გარემოს ერთ-ერთი შემადგენელი ნაწილია. ამიტომ Java-ზე შექმნილია სპეციალური პროგრამირების ინტერფეისი, სახელად Java Print API, რომლის გამოყენებით შეგიძლიათ ისე დაწეროთ პროგრამა, რომ პრინტერის აგებულების დეტალები არ იყოს არსად ნახსენები. ეს ის სამუშაო, რასაც Java საკუთარ თავზე იღებს.

შესრულების გარემოს სხვა მნიშვნელოვანი მაგალითია რელაციური მონაცემთა ბაზა. ერთ-ერთი პირველი Java პროგრამირების ინტერფეისი, სახელად JDBC, უზრუნველყოფდა ნებისმიერი მწარმოებლის მონაცემთა ბაზასთან მიერთების და SQL ბრძანებების შესრულების ერთნაირ მექანიზმს. აბსტრაქციის დონე კიდევ უფრო თვალშისაცემია დღეს, როდესაც Hibernate შემდეგ კი EJB3 ტექნოლოგიები განვითარდა, რომელთა წყალობით დღეს შეგვიძლია ისე ვიმუშაოთ რელაციურ მონაცემთა ბაზასთან, რომ არ გამოვიყენოთ ამ ბაზისთვის დამახასიათებელი SQL ენის დიალექტი.

შესრულების გარემოდ აგრეთვე სხვა Java პროგრამები შეგვიძლია განვიხილოთ. ყოვლისმომცველი გაერთიანების სურვილის წყალობით, Java-ში განვითარდა OSGI ტექნოლოგია, რომლის დახმარებით შეგვიძლია თავად Java-ს პროგრამების, როგორც პროგრამული მოდულების მართვა.

### მეხსიერების ავტომატური მართვა

მეხსიერების გაჟონვა არის C++-ისთვის დამახასიათებელი პრობლემა. Java-ში ეს პრობლემა გადაჭრილია მეხსიერების ავტომატური მართვის მექანიზმით სახელად Gabrage Collector (პირდაპირ თარგმანში, ნაგვის შემგროვებელი), რომელიც თავის თავზე იღებს მეხსიერებაში ყველა იმ ობიექტის პოვნას და წაშლას, რომელიც პროგრამაში არ გამოიყენება.

Java-ში შეუძლებელია ობიექტის მეხსიერებიდან უშუალოდ წაშლა. შეიძლება მხოლოდ მიუთითოთ რომ ესა თუ ის ობიექტი *განკუთვნილია წასაშლელად*, ამ ობიექტზე ყველა კავშირის (reference) მოსპობით.

დამატებით შესაძლებელი გამოვიყენოთ `System.gc();` გამოძახება, რომლის შემდეგ Garbage Collector ეცდება მისთვის მოსახერხებელ დროს გაწმინდოს მეხსიერება. აქ, ისევ, არ იგულისხმება არანაირი გარანტია, რომ მეხსიერება გაწმენდილი იქნება ამ გამოძახების დასრულებისთანავე.

### ზეგავლენა

Java-მ მნიშვნელოვნად შეცვალა ციფრული ტექნოლოგია. მისი ზეგავლენა აშკარაა ამ ტექნოლოგიის გამოყენების თითქმის მთელ სპექტრზე.

გამარჯობა სამყარო
-----------------

გამარჯობა სამყარო Java-ზე, რომელსაც შეტყობინება კონსოლზე გამოაქვს, ასე გამოიყურება:

```
/\*\*
 \* გამარჯობა სამყარო Java პროგრამირების ენაზე.
 \* გამოჰყავს კონსოლზე ტექსტი "გამარჯობა, სამყარო!".
 \*/
public class HelloWorld {
	static public void main(String[] args) {
		System.out.println("გამარჯობა, სამყარო!");
	}
}

```

გამარჯობა სამყარო Java-ს სტანდარტულ გრაფიკული ინტერფეისში (Swing) ასე გამოიყურება:

```
import javax.swing. JOptionPane;

/\*\*
 \* გამარჯობა სამყარო Java პროგრამირების ენაზე.
 \* სტანდარტული გრაფიკული ინტერფეისში (Swing).
 \* გამოჰყავს დიალოგი ტექსტით "გამარჯობა, სამყარო!".
 \*/
public class HelloWorld {
	static public void main(String[] args) {
		JOptionPane.showMessageDialog(null, "გამარჯობა, სამყარო!");
	}
}

```

ორივე ზემოთ მოყვანილი მაგალითი საკმაოდ მარტივად გამოიყურება, განსხვავებით, მაგალითად C-სგან, სადაც გრაფიკულ ინტერფეისში ანალოგიური პროგრამის დაწერა შედარებით შრომატევადია.

ენის სინტაქსი
-------------

 მთავარი სტატია: Java პროგრამირების ენის სინტაქსი.
Java-ს სინტაქსი მნიშვნელოვნად წააგავს C++ სინტაქს. თუმცა Java აგებულია, როგორც ექსკლუზიურად ობიექტურად ორიენტირებული ენა. მთელი საწყისი კოდი იწერება კლასის შიგნით. ამიტომ ყველაფერი Java-ში ობიექტია, გარდა პრიმიტიული ტიპების. გამარტივების მიზნით კლასს შეუძლია იყოს მხოლოდ ერთი კლასის შთამომავალი. ეს შეზღუდვა გარკვეულწილად კომპენსირდება იმით, რომ კლასს შეუძლია უზრუნველყოს ინტერფეისების ნებისმიერი რაოდენობა.

ენას გააჩნია ჩადგმული საშუალებები შეცდომების დამუშავებისთვის და მრავალპროცესიანი პროგრამირებისთვის.

მარტივი მაგალითები
------------------

განვიხილოთ რამდენიმე მარტივი მაგალითი Java-ზე.

### ფაქტორიალის გამოთვლა

პირველ მაგალითში ნაჩვენებია ფაქტორიალის გამოთვლის პროგრამა. ფაქტორიალის გამოსათვლელად ვიყენებთ რეკურსიულ ფორმულას {\displaystyle n!=(n-1)!\cdot n}. პროგრამამ უნდა გამოითვალოს და ჩამოწეროს ფაქტორიალის მნიშვნელობები {\displaystyle n}-ის მნიშვნელობებისათვის {\displaystyle 1}-დან {\displaystyle 100}-მდე.

```
/\*
 \* File: ge.wikipedia.Factorial
 \*/
package ge.wikipedia.Factorial;

import java.math.BigInteger;

/\*\*
 \* ამ პროგრამას გამოაქვს 1-დან 100-მდე ნატურალური რიცხვების ფაქტორიალების სია.
 \* 
 \* @author ვიკი ავტორი
 \*/
public class Factorial {
	/\*\*
 \* აქ იწყება პროგრამის შესრულება.
 \* 
 \* @param args გაშვების პარამეტრები
 \*/
	public static void main(String[] args) {
		for (int i = 1; i <= 100; i++)
			System.out.println(i + ":\t" + calculateFactorial(i));
	}
	
	/\*\*
 \* აბრუნებს მოცემული რიცხვის ფაქტორიალს.
 \* 
 \* @param რიცხვი, რომლის ფაქტორიალსაც ვეძებთ
 \* @return არგუმენტის ფაქტორიალი
 \*/
	public static BigInteger calculateFactorial(int num) {
		if (num == 1 || num == 0)
			return BigInteger.ONE;
		BigInteger bigNum = BigInteger.valueOf(num);
		return bugNum.multiply(calculateFactorial(num - 1));
	}
}

```

* ეს ფაილი შეიცავს `Factorial` კლასის გამოცხადებას, ამიტომ ფაილს, ზოგადი წესის თანახმად, ჰქვია `Factorial.java`.
* `package` დირექტივა განსაზღვრავს პაკეტს (Java-ს ტერმინი სახელობითი სივრცესთვის), რომელსაც მიეკუთვნება ეს კლასი. ჩვენს შემთხვევაში ეს არის `ge.wikipedia.Factorial`. ამიტომ, ზოგადი წესის თანახმად, ჩვენი ფაილი უნდა იდოს `ge/wikipedia/Factorial/` საქაღალდეში.
* `import` დირექტივა უზრუნველყოფს `BigInteger` კლასის მიბმას, პაკეტიდან `java.math`. მიბმა აუცილებელია მოცემული კლასის გამოსაყენებლად. `BigInteger` არის კლასი, რომელიც უზრუნველყოფს ნებისმიერი სიდიდის მთელ რიცხვებთან მუშაობის შესაძლებლობას.
* `public class Factorial` აცხადებს ღია კლასს სახელად `Factorial`.
* `main` ფუნქცია წარმოადგენს იმ წერტილს, საიდანაც ეშვება Java პროგრამა.
* `main` ფუნქციის ტანში ხდება `for` ციკლის გამოძახება. ეს ციკლი წააგავს ანალოგიურ ციკლებს C და C++ ენებში. ციკლის ბიჯი განისაზღვრება `i` ცვლადის მეშვეობით. ეს ცვლადი ინიციალიზირდება და იზრდება გარკვეულ დონემდე (1-დან 100-მდე). თითოული ბიჯისას ხდება კონსოლზე ბიჯის ნომრის და შესაბამისი `calculateFactorial()` ფუნქციის შედეგის გამოტანა.
* ფუნქცია `calculateFactorial()`-ის გამოცხადება ხდება `main` ფუნქციის შემდეგ. ამითი Java განსხვავდება C და C++ ენებისაგან. ამ უკანასკნელებში, აუცილებელია ფუნქციის გამოძახებას წინ ამ ფუნქციის გამოცხადება უძღოდეს. Java-ში ფუნქცია კლასის შიგნით შეიძლება ნებისმიერ ადგილას იყოს გამოცხადებული.
* ფუნქცია `calculateFactorial()` რეკურსიულია. ის იყენებს საკუთარ თავზე მიმართვას, ჩვენს მიერ მოყვანილი რეკურსიული წესის შესაბამისად.
* ფაქტორიალის შედეგის შესანახად გამოიყენება `BigInteger` კლასი, რომელსაც ნებისმიერი სიდიდის მთელი რიცხვის შენახვა შეუძლია (ერთადერთი შეზღუდვა, პროგრამისთვის ხელმისაწვდომი მეხსიერებაა).
* ორი `BigInteger` ერთმანეთზე გადამრავლება ხდება ამ კლასის მეთოდის `multiply` საშუალებით. მეთოდის გამოსაძახებლად გამოიყენება წერტილის ოპერატორი (`.`), რომელიც ერთ-ერთ რიცხვს უდგება `bigNum.multiply(calculateFactorial(num - 1))`.

### აპლეტი

აპლეტი არის Java პროგრამა, რომელსაც შეუძლია შესრულდეს ვებ-ბრაუზერში.

ქვემოთ მოყვანილია მარტივი აპლეტის კოდი. ამ აპლეტის შესრულებისას ეკრანზე გამოდის ღილაკი, რომელზე დაწკაპების გამოდის ტექსტური შეტყობინება.

```
package ქართული.ვიკი.აპლეტი;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JOptionPane;

public class აპლეტი extends JApplet {
	
	@Override
	public void init() {
		super.init();
		JButton ღილაკი = new JButton("დააწკაპე!");
		ღილაკი.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent event) {
				JOptionPane.showMessageDialog(აპლეტი.this, "ღილაკი დაწკაპებულია!");
			}
		});
		getContentPane().setLayout(new FlowLayout());
		getContentPane().add(ღილაკი);
	}

}

```

* აპლეტის შესაქმნელად ჩვენ გვჭირდება კლასი, რომელიც აფართოებს `java.applet.Applet` კლასს. თუმცა ჩვენ გამოვიყენეთ `javax.swing.JApplet`, რომელიც ნაწარმოებია `java.applet.Applet`-დან.

* განსხვავებით ჩვეულებრივი Java პროგრამისგან, აპლეტს არ სჭირდება სპეციალური გამშვები ფუქნცია. აპლეტი ავტომატურად იქმნება გამომძახებელი გარემოს მიერ და გარემოს ინიციალიზაციის შემდეგ ავტომატურად გამოიძახება აპლეტის `init` ფუნქცია.

* `init` ფუნქციის შიგნით ხდება ღილაკის შექმნა და მისი განლაგება აპლეტზე.

* ღილაკის `addActionListener` მეთოდის მეშვეობით უყენდება მისი მოვლენის მსმენელი. ამ შემთხვევაში მოვლენა წარმოადგენს ღილაკზე დაწკაპუნებას. დაწკაპუნების შემდეგ გამოდის შეტყობინების ფანჯარა ტექსტით „გამარჯობა, სამყარო!".

აპლეტი შესაძლოა ჩაიდგას საიტის შემადგენლობაში. ადრეს ამისთვის გამოიტენებოდა `applet` ტეგი. თუმცა დღეს ეს ტეგი მოძველებულად ითვლება.

Mozilla-ს ბრაუზერში წარმოსაჩენად შეგიძლიათ ისარგებლოთ `embed` ტეგით.

```
<embed code="ქართული.ვიკი.აპლეტი.აპლეტი.class"
  width="200" height="200"
  type="application/x-java-applet;version=1.6.0"
  pluginspage="http://java.sun.com/javase/downloads"/>

```

Internet Explorer-ში საჩვენებლად გამოიყენება ტეგი `object`.

```
<OBJECT 
  classid="clsid:8AD9C840-044E-11D1-B3E9-00805F499D93"
  width="200" height="200">
  <PARAM name="code" value="ქართული.ვიკი.აპლეტი.აპლეტი.class">
</OBJECT>

```

JVM
---

 მთავარი სტატია: Java ვირტუალური მანქანა.
Java ვირტუალური მანქანა წარმოადგენს გამშვებს კომპილირებული Java პროგრამისთვის. Java ვირტუალური მანქანა უზრუნველყოფს ოპერაციულ სისტემასთან ურთიერთობას, კლასების ჩატვირთვას და მეხსიერების ავტომატურ კონტროლს.

ძირითადი Java ტექნოლოგიები
--------------------------

**Java SE** სტანდარტული რედაქცია, საბაზისო ყველა ტექნოლოგიისთვის.

**Java EE** კორპორატიული რედაქცია, რომელიც შედგება უამრავი სხვა ქვეტექნოლოოგიისაგან. მათ შორის ყველაზე ცნობილებია სერვლეტები, Java სერვერული გვერდები (JSP), Java სერვერული სახეები (JSF), საწარმო Java ობიექტები (EJB), Java ვებ სერვისები.

**Java ME** მობილური რედაქცია, რომელიც ეშვება მობილურებზე და სხვა მცირერესურსიან მოწყობილობებზე.

**Java Card** სერვის ბარათების დაპროგრამება.

**Java FX** მრავალფეროვანი ვებ-გვერდების ტექნოლოგია, რომელიც კონკურენციას უწევს თავის უფრო ადრეულ ანალოგებს Abobe Flex და Microsoft Silverlight.

რესურსები ინტერნეტში
--------------------

* ჯავას ოფიციალური საიტი ფართო მასებისთვის
* Java პროგრამისტების მთავარი საიტი
* The Java Community Process
* JavaFX-ის ძირითადი საიტი

წყაროები
--------

1. ↑  A brief History of the Green Project.  დაარქივებულია ორიგინალიდან — 2007-06-18. ციტირების თარიღი: 2009-04-18.
2. ↑  History of Java
3. ↑  The Prehistory of Java
4. ↑  The Java History Timeline
5. ↑  JDK 1.0.  დაარქივებულია ორიგინალიდან — 2008-02-05. ციტირების თარიღი: 2008-02-05.
6. ↑  JDK 1.1.  დაარქივებულია ორიგინალიდან — 2008-02-10. ციტირების თარიღი: 2008-02-10.
7. ↑  J2SE 1.2.  დაარქივებულია ორიგინალიდან — 2007-08-16. ციტირების თარიღი: 2007-08-16.
8. ↑  J2SE 1.3.  დაარქივებულია ორიგინალიდან — 2007-08-17. ციტირების თარიღი: 2007-08-17.
9. ↑  J2SE 1.4.  დაარქივებულია ორიგინალიდან — 2007-08-15. ციტირების თარიღი: 2007-08-15.
10. ↑  J2SE 5.0.  დაარქივებულია ორიგინალიდან — 2008-02-07. ციტირების თარიღი: 2008-02-07.
11. ↑  Java SE 6.0
12. ↑  Java SE 6 ზიღითადი ცვლილებების სია
13. ↑  Java SE 6-ში სიახლეების სრული სია
14. ↑  აპლეტების ჩადგმა ვებ-გვერდებში.  დაარქივებულია ორიგინალიდან — 2009-03-07. ციტირების თარიღი: 2009-04-24.
15. ↑  Java SE ოფიციალური საიტი
16. ↑  Java EE ოფიციალური საიტი
17. ↑  Java ME ოფიციალური საიტი
18. ↑  Java Card ოფიციალური საიტი
19. ↑  Java FX ოფიციალური საიტი
20. ↑  Java FX დეველოპერების საიტი

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| ხ • გ • რ
პროგრამირების ენები |
| --- |
|  |
|  ობიექტზე-ორიენტირებული | 
* გრუვი
* D
* ეიფელი
* პითონი
* რუბი
* Objective-C
* C++
* C#
* ჯავა
* ჯავასკრიპტი
 |
|  |
|  ბრძანებითი | 
* ასემბლერი
* კობოლი
* ლუა
* პერლი
* PHP
* C
 |
|  |
|  ფუნქციური | 
* ობიექტური კამლი
* Clojure
* F#
* Standard ML
 |
|  |
|  თანადროული | 
* ადა
* ერლანგი
 |

 |