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

პროექტის შესახებ

ცოტა ხნის წინ, JetBrains-მა, კომპანიამ, რომელიც ქმნის განვითარების გარემოს, გამოაცხადა თავისი ახალი პროდუქტი - Kotlin პროგრამირების ენა. კრიტიკის ტალღა მოხვდა კომპანიაში: კრიტიკოსებმა შესთავაზეს, რომ კომპანიას მოეგო გონს და დაესრულებინა Scala-ს დანამატი, ნაცვლად საკუთარი ენის განვითარებისა. Scala-ს დეველოპერებს ნამდვილად აკლიათ კარგი განვითარების გარემო, მაგრამ დანამატების დეველოპერების პრობლემები გასაგებია: Scala, რომელიც დაიბადა შვეიცარიელი მკვლევარების წყალობით, აერთიანებს ბევრ ინოვაციურ სამეცნიერო კონცეფციას და მიდგომას, რამაც კარგი განვითარების ინსტრუმენტის შექმნა უკიდურესად რთულ ამოცანად აქცია. . ამ დროისთვის, JVM-ისთვის თანამედროვე სტატიკურად აკრეფილი ენების სეგმენტი მცირეა, ამიტომ გადაწყვეტილება, შექმნათ თქვენი საკუთარი ენა, მისთვის განვითარების გარემოსთან ერთად, ძალიან შორსმჭვრეტელია. მაშინაც კი, თუ ეს ენა საერთოდ არ გაიდგამს ფესვებს საზოგადოებაში, JetBrains მას უპირველეს ყოვლისა თავისი საჭიროებისთვის ამზადებს. ნებისმიერ Java პროგრამისტს შეუძლია გაიგოს ეს საჭიროებები: Java, როგორც ენა ძალიან ნელა ვითარდება, ენაში არ ჩნდება ახალი ფუნქციები (უკვე რამდენიმე წელია ველოდებით პირველი რიგის ფუნქციებს), ენის ძველ ვერსიებთან თავსებადობა ხდის ამას. შეუძლებელია ბევრი სასარგებლო რამის გამოჩენა უახლოეს მომავალში (მაგალითად, წესიერი ტიპის პარამეტრიზაცია). პროგრამული უზრუნველყოფის შემქმნელი კომპანიისთვის პროგრამირების ენა არის მთავარი სამუშაო ინსტრუმენტი, ამიტომ ენის ეფექტურობა და სიმარტივე არის ინდიკატორი, რომელზედაც დამოკიდებულია არა მხოლოდ მისთვის ხელსაწყოების შემუშავების სიმარტივე, არამედ პროგრამისტის კოდირების ხარჯებიც, ანუ რამდენად ადვილი იქნება ეს. იყოს ამ კოდის შენარჩუნება და მისი გაგება.

ენის შესახებ

ენა სტატიკურად არის აკრეფილი. მაგრამ ჯავასთან შედარებით, Kotlin შემდგენელი ამატებს ინფორმაციას ტიპს იმის შესახებ, შეიძლება თუ არა მითითება შეიცავდეს null-ს, რაც ამკაცრებს ტიპის შემოწმებას და უფრო უსაფრთხოს ხდის შესრულებას:

Fun foo(text:String) ( println(text.toLowerCase()) // NPE? არა! ) val str:String? = null // სიმებიანი? -- ნულოვანი ტიპი foo(str) //<- компилятор не пропустит такой вызов -- // тип str должен быть String, чтобы // передать его в foo

იმისდა მიუხედავად, რომ ამ მიდგომამ შეიძლება გადაარჩინოს პროგრამისტი NPE-თან დაკავშირებული მრავალი პრობლემისგან, Java პროგრამისტისთვის თავიდან ეს არასაჭირო ჩანს - თქვენ უნდა გააკეთოთ არასაჭირო შემოწმებები ან კონვერტაციები. მაგრამ კოტლინში პროგრამირების გარკვეული დროის შემდეგ, ჯავაში დაბრუნების შემდეგ, გრძნობთ, რომ აკლიათ ეს ინფორმაცია ტიპის შესახებ და ფიქრობთ Nullable/NotNull ანოტაციების გამოყენებაზე. ამასთან დაკავშირებულია java-სთან უკუშეთავსებადობის საკითხები - ეს ინფორმაცია არ არის java bytecode-ში, მაგრამ როგორც ვიცი, ეს საკითხი ჯერ კიდევ მოგვარების პროცესშია და ამ დროისთვის java-დან შემოსული ყველა ტიპი ნულდება.

სხვათა შორის, ჩამორჩენილი თავსებადობის შესახებ: Kotlin შედგენილია JVM ბაიტეკოდში (ენის შემქმნელები დიდ ძალისხმევას ხარჯავენ თავსებადობის შესანარჩუნებლად), რაც საშუალებას აძლევს მას გამოიყენოს იმავე პროექტში java-სთან და java-ს ურთიერთგამოყენების შესაძლებლობა. და Kotlin კლასები ქმნის ბარიერს Kotlin-ის დანერგვის დიდ არსებულ, ძალიან მინიმალურ java პროექტში. ამ მხრივ, მნიშვნელოვანია მრავალი java-ს განვითარების შესაძლებლობა პროექტის შექმნით მთლიანად კოტლინში. მაგალითად, ჩემთვის თითქმის ადვილი იყო Spring-webmvc-ზე დაფუძნებული პატარა პროექტის გაკეთება.

მოდით შევხედოთ კონტროლერის ფრაგმენტს:

Path(array("/notes/")) კონტროლერის კლასი NotesController ( პირადი ავტომატური გაყვანილობა val notesService: NotesService? = null path(array("all")) fun all() = render("notes/notes") ( addObject(" შენიშვნები", notesService!!.ყველა) ) //... )

კოტლინში ანოტაციების გამოყენების თავისებურებები ჩანს: ზოგან ის არ გამოიყურება ისე მოწესრიგებულად, როგორც java-ში (ეს ეხება განსაკუთრებულ შემთხვევებს, მაგალითად, ერთი ელემენტის მასივს), მაგრამ ანოტაციები შეიძლება გამოყენებულ იქნას, როგორც „ხელნაკეთი“ საკვანძო სიტყვები, როგორიცაა როგორც ავტომატური ან კონტროლერი (თუ იმპორტის დროს მიუთითებთ მეტსახელის ტიპს) და შესაძლებლობების თვალსაზრისით, ანოტაციები უფრო ახლოსაა რეალურ კლასებთან.

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

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

გართობა doSomething(thing:()->Unit) ( // გამოაცხადეთ ფუნქციის ტიპის პარამეტრი // ()->ერთეული არ იღებს არაფერს და // არაფერს აბრუნებს მნიშვნელოვან რამეს() // call ) doSomething() ( // და აქ ჩვენ ვქმნით ფუნქციას ტიპის // ()->Unit და გადავცემთ doShomething ფუნქციას // თუ ფუნქცია არის ბოლო პარამეტრი, შეგიძლიათ // გადაიტანოთ იგი ზარის ფრჩხილების გარეთ println("Hello world "))

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

გართობა სია .ფილტრი(პირობა:(T)->ლოგიკური): სია ( val შედეგი = სია () for(item in this) ( if(condition(item)) result.add(item) ) return result ) val someList = list(1, 2, 3, 4).ფილტრი ( it > 2 ) // someList= =

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

კლასების თემისა და სიმოკლეობის საილუსტრაციოდ, მოდით შევხედოთ შემდეგ კოდს:

// bean კლასების შექმნა ხდება // ლაკონური, ველები შეიძლება გამოცხადდეს // პირდაპირ კონსტრუქტორის დეკლარაციის კლასში TimeLord(val name:String) // კლასს შეიძლება საერთოდ არ ჰქონდეს სხეული კლასი TARDIS(val მფლობელი:TimeLord) fun main (არგ: მასივი ) ( val ექიმი = TimeLord ("ექიმი") val tardis = TARDIS(ექიმი) println(tardis.owner.name) )

რამდენიმე სტრიქონში შევძელით ორი კლასის გამოცხადება, ორი ობიექტის შექმნა და TARDIS-ის მფლობელის სახელის დაბეჭდვა! თქვენ შეგიძლიათ შეამჩნიოთ, რომ კლასი გამოცხადებულია მისი ერთადერთი შესაძლო კონსტრუქტორის პარამეტრებით, რომლებიც ასევე არის მისი თვისებების დეკლარაცია. ძალიან მოკლე, მაგრამ ინფორმატიული. რა თქმა უნდა, იქნებიან ისინი, ვინც დაგმობენ ერთზე მეტი კონსტრუქტორის გამოცხადების შეუძლებლობას, მაგრამ მეჩვენება, რომ ამას აქვს თავისი პრაგმატიზმი - ბოლოს და ბოლოს, ჯავაში რამდენიმე კონსტრუქტორი ან გაძლევთ საშუალებას გამოაცხადოთ ნაგულისხმევი პარამეტრები, რომლებსაც კოტლინი მხარს უჭერს ენაზე. დონეს, ან გადაიყვანეთ ერთი ტიპი მეორეზე, რომლითაც ეს კლასი იმუშავებს და ეს უკვე უსაფრთხოდ შეიძლება დარჩეს ქარხნულ მეთოდზე. ყურადღება მიაქციეთ „ცვლადების“ და ველების დეკლარაციას. კოტლინი გვაიძულებს გავაკეთოთ არჩევანი: val ან var. სადაც val აცხადებს უცვლელ საბოლოო მითითებას, ხოლო var აცხადებს ცვლადს, რაც ხელს უწყობს ცვალებადი მიმართვების ფართო გამოყენების თავიდან აცილებას.

მაგალითი

ახლა ჩვენ მივედით იქ, სადაც შეგვიძლია რაიმე უფრო საინტერესო გავაკეთოთ. ინტერვიუების დროს ხშირად ვაძლევ დავალებას ხის დანერგვა, მასზე გავლა და ელემენტთან რაიმე მოქმედების განსაზღვრა. ვნახოთ, როგორ ხორციელდება ეს კოტლინში.

მე მინდა გამოიყურებოდეს გამოყენება:

სახალისო მთავარი (არგ: მასივი ) ( // შექმენით პატარა ხე val tree= ხე("ფესვი") ( node("1-1") ( node("2-1") node("2-2") ) კვანძი("1-2" " ) ( node ("2-3") ) ) // გადაკვეთეთ და ამობეჭდეთ მნიშვნელობები კონსოლის ხეზე.ტრავერსი (println(it) ) )

ახლა ვცადოთ ამის განხორციელება. მოდით შევქმნათ ხის კვანძის კლასი:

/** * @param მნიშვნელობა კვანძის მონაცემები */ კლასი Node (val მნიშვნელობა:T) ( // node kids private val children:List > = arrayList() /** * მეთოდი, რომელიც ქმნის და ამატებს შვილს კვანძში * @param მნიშვნელობა ახალი კვანძისთვის * @param init ფუნქცია ახალი კვანძის ინიციალიზაციისთვის, სურვილისამებრ * პარამეტრი */ fun node(მნიშვნელობა: T, საწყისი: Node .()->ერთეული = ()): კვანძი ( val კვანძი = კვანძი (მნიშვნელობა) node.init() children.add(node) return node ) /** * მეთოდი რეკურსიულად კვეთს ყველა შვილობილ კვანძს, დაწყებული თავად * კვანძიდან, თითოეულ კვანძს ეცნობება დამმუშავებლის შესახებ * @param handler ფუნქციის დამმუშავებელი თითოეული კვანძის მნიშვნელობა */ fun traverse( handler:(T)->Unit) ( handler(value) children.forEach (ბავშვი -> ბავშვი.ტრავერსი(მმუშავებელი)) )

ახლა მოდით დავამატოთ ფუნქცია ხის ზედა ნაწილის შესაქმნელად:

/** * ქმნის ხის კვანძს მნიშვნელობის მნიშვნელობით და ახდენს * მისი ბავშვების ინიციალიზებას init მეთოდით. */ გართობა ხე (მნიშვნელობა: T, საწყისი: კვანძი .()->ერთეული): კვანძი

( val კვანძი = Node(მნიშვნელობა) // გამოძახება init მეთოდის // პარამეტრში გადაცემული კვანძის ობიექტზე node.init() დაბრუნების კვანძი)

კოდის ორ ადგილას გამოიყენებოდა კონსტრუქცია, როგორიცაა Node.()->Unit, მისი მნიშვნელობა არის ის, რომ ფუნქციის ტიპი მოსალოდნელია შეყვანის სახით, რომელიც შესრულდება, როგორც Node ტიპის ობიექტის მეთოდი. ამ ფუნქციის სხეულიდან არის წვდომა ამ ობიექტის სხვა მეთოდებზე, როგორიცაა Node.node() მეთოდი, რომელიც საშუალებას გაძლევთ გააკეთოთ ხის ინიციალიზაცია მაგალითში აღწერილის მსგავსი.

დასკვნის ნაცვლად

თუ ენა გაინტერესებთ, ენის შესახებ ყველა ინფორმაცია შეგიძლიათ იხილოთ პროექტის ოფიციალურ ვებსაიტზე, მათი წყაროები შეგიძლიათ იხილოთ github-ზე და აღმოჩენილი შეცდომები შეიძლება განთავსდეს Issue Tracker-ში. ჯერ კიდევ ბევრი პრობლემაა, მაგრამ ენის შემქმნელები აქტიურად ებრძვიან მათ. ახლა გუნდი მუშაობს milestone 3-ის ჯერ კიდევ არც თუ ისე სტაბილურ ვერსიაზე, სტაბილიზაციის შემდეგ, როგორც ვიცი, იგეგმება ენის გამოყენება JetBrains-ის კომპანიაში, რის შემდეგაც უკვე იგეგმება პირველი გამოშვება.

ტეგები: ტეგების დამატება

2017 წელს იყო ახალი აჟიოტაჟი YP-ის გარშემო (პროგრამირების ენა)კოტლინი და ამ ფონზე ასევე მინდა გითხრათ სხვა სიახლეების შესახებ სმარტფონებისთვის ანდროიდის ოპერაციულ სისტემაზე დაფუძნებული პროგრამების შემუშავებაში. მაგრამ ეს არის ჩემი პირადი ბლოგი და არა რაიმე სახის აკადემიური რესურსი და ამიტომ, პირველ რიგში, თავს უფლებას მივცემ გვერდით რამდენიმე ლირიკულ გადახვევას, მზერა წარსულისკენ გავამახვილო.

ისტორიული ექსკურსია

ჩემი პირველი გაცნობა Android ოპერაციული სისტემით მომუშავე სმარტფონების პროგრამირებასთან იყო 2012 წლის დასაწყისშიანუ ზუსტად 6 წლის წინ. იმ შორეულ დროში Google-ს ჯერ არ ჰქონდა შექმნილი თავისი ბრწყინვალე IDE (Integrated Development Environment, Integrated Development Environment)მე და Android Studio-ში ვართ Eclipse IDE-ში დაყენებული ADT მოდულით (Android განვითარების ინსტრუმენტები, Android Developer Tools). ჩვენი გაცნობის მიზეზი იყო ჩემი პირველი სმარტფონის, HTC Desire HD-ის შეძენა ერთი წლით ადრე, 2011 წლის ზაფხულის დასაწყისში.

Java ითვლებოდა Android-ის პროგრამირების მშობლიურ ენად. ეს იყო ჩემთვის ახალი ენა, ამიტომ მქონდა სამმაგი გამოწვევა: ახალი IDE, ახალი ენა და ახალი OS. (ოპერაციული სისტემა), და ეს ყველაფერი ერთდროულად. მიუხედავად ამისა, რაღაცნაირად ვისწავლე ანდროიდისთვის პროგრამების წერა და ერთი კომერციული პროდუქტიც დავწერე, რისთვისაც სიამოვნებით მივიღე ჯილდო 1000 ევრო.

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

კიდევ ერთი წლის შემდეგ 2013 წლის დასაწყისშიმე კი დავიწყე სპეციალური ბლოგის წერა, სახელწოდებით "Android, ხრიკები შენი ყურებით" დამახასიათებელი ეპიგრაფით " ზღარბები ტიროდნენ, გაუკეთეს ინექცია, მაგრამ განაგრძეს კაქტუსის ღრღნა...“, რომელშიც პერიოდულად ვაქვეყნებდი გადაწყვეტილებებს გარკვეული პრობლემების შესახებ, რომლებიც დამხვდა და ასევე ვაქვეყნებდი დამატებით ფონურ ინფორმაციას, თითქოს ჩემი მეხსიერებისთვის.

2014 წელსგამოჩნდა IDE-ის პირველი სტაბილური ვერსია თავად Google-ისგან (თუმცა დაფუძნებულია IDE IntelliJ IDEA-ზე, რომელიც დაწერილია ლეგალურად ჩეხურ კომპანიაში JetBrains, რომელიც დაარსდა პრაღაში სამი რუსი პროგრამისტის მიერ).

ზოგადად, ყველაფერი დაიწყო რუსული კომპანია StarSoft-ით, რომელმაც დაიწყო თავისი საქმიანობა 1991 წლის აგვისტოს გადატრიალების შემდეგ პეტერბურგის დამოუკიდებელ ჰუმანიტარულ აკადემიაში პროგრამული უზრუნველყოფის ლაბორატორიის ბაზაზე, შემდეგ კი სამი ადამიანისგან შედგებოდა. 1993 წელს დაიწყო მუშაობა Together პროექტზე (პროგრამული დიზაინის ინსტრუმენტი), რომლის იდეა შემოგვთავაზა გერმანიიდან ჩამოსულმა გერმანელმა. 1995 წელს კომპანიას ეწოდა STAR SPb და ოფიციალურად დარეგისტრირდა STAR Group-ის რუსეთის წარმომადგენლობად. 1999 წელს, "რუსულ-გერმანული" კომპანია TogetherSoft, რომელიც შედგებოდა სპეციალისტებისგან, რომლებიც მუშაობდნენ Together პროდუქტზე, დაიშალა STAR SPb-დან. თანადამფუძნებლებს შორის, როგორც ყოველთვის, იყვნენ ამერიკელები, რომლებმაც გადაწყვიტეს კარგი პროგრამისტების სასწრაფოდ გადაყვანა სანკტ-პეტერბურგიდან ევროპაში და იმავე 1999 წელს, TogetherSoft-ის საუკეთესო გუნდი. (დაახლოებით 50 ადამიანი)წავიდა პრაღაში. მათ შორის იყო JetBrains-ის სამი მომავალი დამფუძნებელი. ასე რომ, 2000 წელს მათ დააარსეს კომპანია JetBrains და დარეგისტრირდნენ იმავე ადგილას, სადაც იმ დროს ცხოვრობდნენ, პრაღაში.

JetBrains-ის ფლაგმანი პროდუქტია IntelliJ IDEA, IDE მრავალი პროგრამირების ენისთვის. Google-მა ის აიღო, როგორც მისი IDE Android Studio-ს საფუძველი. სხვათა შორის, Google-ის თანადამფუძნებელიც რუსეთიდანაა. ცოტას თუ გათხარავთ, რუსული ფესვები ყველგან აჩენს... მოსკოვში დაიბადა და 5 წლამდე ცხოვრობდა, შემდეგ კი ოჯახი 1979 წელს ამერიკაში წავიდა ემიგრაციაში, როგორც მაშინ ებრაელებს სჩვევიათ. ანტისემიტიზმის გამო, კერძოდ, ებრაელების უნივერსიტეტებში შესვლის კვოტების არსებობა. თავდაპირველად, ებრაელები, როგორც ხალხი, იზოლირებულნი არიან, ყოველმხრივ ხაზს უსვამენ ღვთის რჩეულობას და არ მალავენ თავიანთ არა ყოველთვის მისაღებ მენტალიტეტს სხვა დომინანტური რელიგიისა და განსხვავებული მენტალიტეტის მქონე რეგიონებში, შემდეგ კი გაკვირვებულნი არიან შედეგით. . თუმცა ეს სხვა თემაა. მიუხედავად მისი, რბილად რომ ვთქვათ, სკეპტიკური დამოკიდებულებისა ყოფილი სამშობლოს მიმართ (სხვას რას უნდა ელოდო საბჭოთა ემიგრანტების მიერ გაზრდილი ადამიანისგან)მე მთლიანად ვიზიარებ მის შეხედულებებს, კერძოდ ინტერნეტში. და ბევრი კრიტიკული განცხადება რუსეთის შესახებ საკმაოდ სამართლიანია, თუმცა უსიამოვნოა უცხოელის ტუჩებიდან მოსმენისას. თუმცა ისევ გავფანტე...

ასე რომ, როდესაც Android Studio გამოჩნდა, მე მაშინვე გადავედი მასზე, როგორც პოტენციურად უფრო პერსპექტიულ IDE-ზე Android-ისთვის. უნდა ითქვას, რომ თავიდან შესამჩნევი იყო მისი დადებითი და უარყოფითი მხარეები Eclipse-თან შედარებით. მიუხედავად ამისა, კიდევ ბევრი უპირატესობა იყო და მე მასზე მტკიცედ ჩავდექი.

როგორც მოყვარული, არარეგულარულად ვაპროგრამებ და ანდროიდის მხრივ, ბოლო 2017 წელი სრულიად გამომრჩა. ახლა კი გადავწყვიტე IDE-ის განახლება და ვნახო, რა ახალი რამ გამოჩნდა იქ დროის შუალედში. და აღმოჩნდა, რომ იქ ბევრი მნიშვნელოვანი რამ გამოჩნდა! ქვემოთ ჩამოვთვლი განსაკუთრებულად გამორჩეულ სიახლეებს, რომლებსაც ძალიან დადებითად ვაფასებ.

ახალი პროგრამირების ენა Kotlin

ბოლო დრომდე Android Studio-ს მხოლოდ Java-ში პროგრამირების მხარდაჭერა ჰქონდა (ჯავა, ადრე უფრო ხშირად ითქვა ჯავა. ენას ყავის ბრენდის სახელი ჰქვია, რომელიც, თავის მხრივ, ინდონეზიაში მდებარე კუნძულის სახელს ატარებს)და C++-ში მშობლიური კოდისთვის. Java ენა არც თუ ისე ძველია, მაგრამ მისი გამოყენების შედარებით ახალგაზრდა ფოკუსის გათვალისწინებით (მრავალ პლატფორმა), საკმაოდ ხანდაზმული. იგი შეიქმნა ცნობილი კომპანია Sun Microsystems-ის მიერ 1995 წელს. ენას თავდაპირველად მუხა ერქვა ("მუხა")და შეიქმნა სამომხმარებლო ელექტრონული მოწყობილობების პროგრამირებისთვის. შემდეგ მას ეწოდა Java და გამოიყენებოდა კლიენტის აპლიკაციებისა და სერვერის პროგრამული უზრუნველყოფის დასაწერად. მოგვიანებით სხვა გამოყენებაც გამოჩნდა.

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

და სულ ახლახან, 2017 წლის ბოლოს, გამოვიდა Android Studio 3.0, რომელმაც Java და C++ ენებთან ერთად დაიწყო Kotlin ენის მხარდაჭერა. (კოტლინი), რომელიც, Java-ს მსგავსად, შექმნილია იმავე ვირტუალური მანქანისთვის იგივე ბაიტეკოდის შესაქმნელად, მაგრამ აქვს განსხვავებული სინტაქსი, რომელიც საშუალებას გაძლევთ დაწეროთ ბევრად უფრო კომპაქტური წყარო კოდი. ამავდროულად, წყაროს ფაილები ორივე ენაზე შეიძლება შერეული იყოს ერთ პროექტში შეზღუდვების გარეშე, რაც შესაძლებელს ხდის ეტაპობრივად გადაიტანოს მთელი პროექტი Kotlin-ზე.

ენა სრულიად სუფთაა. მისი განვითარება 2010 წელს დაიწყო, საზოგადოებას წარუდგინეს 2011 წელს, ანდროიდზე პროგრამირება შესაძლებელი გახდა 2012 წელს, ოფიციალური გამოშვება კი სულ ახლახანს, 2016 წელს გამოვიდა. სხვათა შორის, ტრადიციის მიხედვით (იგივე ჯავა)ენას კუნძულის სახელი ჰქვია. ამჯერად ეს არის რუსული კუნძული კოტლინი ფინეთის ყურეში, რომელზედაც მდებარეობს ქალაქი კრონშტადტი. და ენა შეიმუშავეს პეტერბურგის პროგრამისტებმა, ყველა ერთსა და იმავე კომპანიაში JetBrains! ოჰ, როგორ, ნამდვილი რუსული პროგრამირების ენა! [პატრიოტებმა დროშები უნდა აფრიალონ და ამ პოსტის ავტორი უკვე წრეებში დადის ოთახში და მუქარით აფრიალებს თანამშრომლებს...]

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

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

არქიტექტურული კომპონენტები Android-ისთვის Google-ისგან

ასევე ძალიან კომპაქტური აღმოჩნდა SQLite მონაცემთა ბაზის შექმნა და გამოყენება Room ბიბლიოთეკის გამოყენებით, რომელიც წარმოადგენს კარგად ცნობილ SQLiteOpenHelper კლასს. Room-ის გამოსაყენებლად საკმარისია აღვწეროთ ორი პატარა კლასი, რომელიც აღწერს ცხრილს და მონაცემთა ბაზას და ერთი პატარა ინტერფეისი, რომელიც აღწერს ამ მონაცემთა ბაზასთან ურთიერთქმედების ფუნქციებს. Kotlin-ში არ არის საჭირო ამ ყველაფრის სხვადასხვა ფაილში გადატანა. ამ მწირი ინფორმაციის საფუძველზე, Room გაიმეორებს ყველა მოქმედებას, რომელიც ადრე უნდა ჩაწერილიყო უზარმაზარ ფაილებში, ავტომატურად და შინაგანად. სასწაულები!

რეალურ აპლიკაციებში, თქვენ უნდა აკონტროლოთ მონაცემთა ბაზაში ცვლილებები და ავტომატურად განაახლოთ ინფორმაცია ვიზუალურ კომპონენტებში. ამიტომ, Room კომპონენტი ყველაზე ხშირად გამოიყენება არა თავისთავად, არამედ LiveData კომპონენტთან ერთად android.arch.lifecycle ბიბლიოთეკიდან. ეს კომპონენტი ასევე მარტივი გამოსაყენებელია. მონაცემები, რომლებსაც თვალყურის დევნება სჭირდება, გადაიცემა მონაცემთა ბაზიდან ცვლადში არა პირდაპირ, არამედ LiveData კლასის სახით, რომელმაც ეს მონაცემები პარამეტრად მიიღო Room-ის შიგნით. ამის შემდეგ, მთავარ კოდში, კოტლინის ერთი ხაზი ადგენს მათ მონიტორინგს და ვიზუალური კომპონენტის განახლების ფუნქციას, რომელიც ამოქმედდება მონაცემთა ცვლილებისას. ყველაფერი ელემენტარულია!

კიდევ ერთი სასარგებლო კომპონენტი android.arch.lifecycle ბიბლიოთეკიდან, რომელიც ხსნის აქტივობის მონაცემების შენახვის თავის ტკივილს ეკრანის ბრუნვისას არის ViewModel. ადრე საჭირო იყო ყველანაირი გენიალური ხელჯოხების დაწერა, რათა მონაცემები არ დაიკარგოს და გამოთვლები არ შეწყვეტილიყო. ახლა ამისთვის არის ოფიციალური კომპონენტი! თუ ადრე ჩვენ გამოვყავით ინტერფეისი კოდისგან (მარკეპი და აქტივობა), მაშინ ახლა დროა გამოვყოთ კოდი, რომელიც მხოლოდ აქტივობის სასიცოცხლო ციკლის განმავლობაში უნდა მუშაობდეს (მაგალითად, მომხმარებლის ინტერფეისის ფუნქციონირების უზრუნველყოფა), კოდიდან, რომელიც უნდა იმუშაოს კონკრეტული აქტივობის სასიცოცხლო ციკლის მიღმა (მაგალითად, მონაცემების მიღება, დამუშავება და გადაცემა). ამ შემთხვევაში, ჩვენ შეგვიძლია ავტომატურად წავიკითხოთ კოდის მეორე ნაწილის შედეგი ეკრანის შემობრუნების შემდეგ ხელახლა შექმნილ აქტივობაში.

მთელი ამ სქემის განსახორციელებლად ViewModel-ით, ასევე საჭიროა მინიმალური მოქმედებები. ცალკე კლასი იწერება კოდით, რომელიც არ უნდა შეწყდეს (ე.წ. ხედვის მოდელი, არ ვიცი რატომ "მოდელი"; იქნებ არასწორად ვთარგმნი), ხოლო მთავარ კოდში, ერთ ხაზზე, გამოიძახება მოდელის პროვაიდერი, რომელსაც ეს კლასი გადაეცემა პარამეტრად. პროვაიდერი ან აბრუნებს არსებული მოდელის კლასის ობიექტს (ეკრანის შემობრუნების შემდეგ), ან ქმნის ასეთ ობიექტს გავლილი კლასის საფუძველზე, თუ ის ჯერ არ არსებობს და ასევე აბრუნებს (როდესაც აქტივობა პირველად იწყება). აქტივობას ყოველთვის შეუძლია წვდომა ამ ობიექტის ფუნქციებსა და ცვლადებზე.

სამივე კომპონენტი გაერთიანებულია ოფიციალური სახელწოდებით Android Architecture Components. მართალია, ის ასევე შეიცავს LifeCycle კომპონენტს, რომელიც ასევე მდებარეობს android.arch.lifecycle ბიბლიოთეკაში, მაგრამ ის გამოიყენება LiveData-სთან მჭიდრო კავშირში და საერთოდ არ გამოვყოფდი მას. ასეთი მაღალი დონის კომპონენტების დანერგვა არის მისასალმებელი ნაბიჯი სწორი მიმართულებით Google-ისთვის. დიდი ხანია ვწუწუნებ იმაზე, თუ რამდენ სხვადასხვა კლასში უნდა გავაფართოვო თავი და დავაკავშირო ისინი ყველა ერთმანეთთან, რომ პრიმიტიული სახელმძღვანელოების მაგალითებზე ცოტა მეტი არაფერი გამოვიდეს. და ბოლოს, ბიბლიოთეკებს შორის დაიწყო სწორი კომპონენტების გამოჩენა. იმედი მაქვს ეს ტენდენცია გაგრძელდება.

ვიზუალური ინტერფეისის რედაქტორი

ინოვაციები, რომლებიც აღმოვაჩინე სმარტფონების პროგრამირებაში, ამით არ მთავრდება. დაბადებიდან Android Studio-ს ძალიან გაუჭირდა ვიზუალური ინტერფეისის რედაქტორის სტაბილურობა და პროგნოზირებადობა, თუმცა ის უფრო სტაბილური იყო ვიდრე Eclipse-ში. ინტერფეისის xml მარკირების პირდაპირ რედაქტირებაც კი, ძალიან რთული იყო ყველა ამ განლაგების და სხვა ვიზუალური კომპონენტების კონფიგურაცია ისე, რომ ისინი გამოჩენილიყო სწორ ადგილებში და სწორი ფორმით.

საბედნიეროდ, Android Studio-ში, 2.2 ვერსიიდან დაწყებული, იმის ნაცვლად, რომ აეშენებინათ gimor ინტერფეისი ელემენტების ხაზოვანი განლაგების განლაგებით. (ხაზოვანი განლაგება)შემოთავაზებულია ახალი იძულებითი განლაგების გამოყენება (ConstraintLayout). გარდა ამისა, საბოლოოდ დასრულდა ვიზუალური რედაქტორი. ამ ყველაფერმა ერთად ძალიან დადებითი გავლენა მოახდინა. ახლა არც ისე რთულია ელემენტების სწორად განლაგება და ისინი საკმაოდ პროგნოზირებად იქცევიან, ახლა თქვენ არ შეგიძლიათ შეეხოთ xml მარკირებას, არამედ შეასრულოთ ყველა მოქმედება ვიზუალურ რედაქტორში.

Kotlin პროგრამირების ენა, რომელიც შემუშავებულია პეტერბურგის კომპანია JetBrains-ის მიერ, გახდა Android-ის განვითარების ოფიციალური ენა. ეს ოფიციალურად გამოცხადდა Google I/O კონფერენციაზე. კოტლინის გუნდს ხელმძღვანელობს ITMO უნივერსიტეტის კურსდამთავრებული ანდრეი ბრესლავი. რატომ არის კოტლინი ასე საყვარელი IT გიგანტის მიერ ბევრ სხვა "ახალგაზრდა" ენას შორის, როგორ და რატომ ჩნდება ახალი პროგრამირების ენები ზოგადად, წაიკითხეთ ექსპერტების კომენტარებში და ITMO.NEWS ინფორმაციის კოლექციაში.

როგორ ვითარდება პროგრამირების ენები

სხვადასხვა შეფასებით, მსოფლიოში უკვე არსებობს ორი ათასზე მეტი სხვადასხვა პროგრამირების ენა. განახლებები მუდმივად გამოდის ძველი ენებისთვის, ასევე ჩნდება ახალი ენები. როდესაც ენის სინტაქსი არ იცვლება, არამედ მხოლოდ უფრო რთული და ფართოვდება, დეველოპერს მხოლოდ მცირე ვარჯიში სჭირდება, რათა განაგრძოს წერა თავის საყვარელ ენაზე. ზოგჯერ თავად ენის სტრუქტურა იცვლება და შემდეგ პროგრამისტს ხანდახან უწევს ხელახლა სწავლა, განახლებულ ენაზე ადაპტირება. როგორც წესი, ახალ სტრუქტურაზე გადასვლა ხდება თანდათანობით და ნაწილებად, ანუ პროგრამის კოდის მხოლოდ 10-20% იწყება ახალი ენის გამოყენებით.

« პროგრამისტები არ იყვნენ კმაყოფილი C++ და Java ენებით, რადგან ეს საკმაოდ რთული ენებია და პირველი უფრო რთულია, ვიდრე მეორე. აქედან გამომდინარე, გამოჩნდა Scala ენა, რომელიც ბევრ პროგრამისტს მოსწონს, მაგრამ ის ასევე ძალიან რთულია. JetBrains-ის უზარმაზარმა გამოცდილებამ სხვადასხვა პროგრამირების ენებისთვის პროგრამების განვითარების ინსტრუმენტების შექმნისას საშუალება მისცა მას შვიდ წელიწადში შეექმნა Kotlin ენა, რომელიც სრულად თავსებადია Java-სთან, მაგრამ მასზე მარტივი და მოსახერხებელი. პროგრამირების ენები მუდმივად ვითარდება; ამის მიუხედავად, თითოეული ენა უფრო ეფექტურია გარკვეულ სფეროში, სადაც ის ყველაზე ხშირად გამოიყენება. ენების შექმნის მიმართულებაც კი არსებობს, როდესაც ისინი შემუშავებულია კონკრეტული საგნისთვის“, - განაცხადა ITMO უნივერსიტეტის პროგრამირების ტექნოლოგიების დეპარტამენტის ხელმძღვანელმა.

დღეს, ზოგიერთი კომპანია ადგენს საკუთარ ენობრივ რეიტინგებსაც კი. მაგალითად, კომპანია TIOBE, რომელიც სპეციალიზირებულია პროგრამული უზრუნველყოფის ხარისხის შეფასებაში, 2001 წლიდან ყოველთვიურად ითვლის გარკვეული ენების პოპულარობის ინდექსს. გენერირებული სია შეიცავს 50 ხაზს და იმისათვის, რომ პროგრამირების ენა შევიდეს ინდექსში, დეველოპერებმა უნდა დაწერონ შესაბამისი წერილი კომპანიას. გაანგარიშება ეფუძნება 25 ინტერნეტ საძიებო სისტემის მონაცემებს. ჯერჯერობით რეიტინგში დიდი სხვაობით ლიდერობს Java, რასაც მოჰყვება C. ამავდროულად, სიის შემდგენელები ხაზს უსვამენ, რომ გასული წლის განმავლობაში პროგრამირების ორივე ენა ნაკლებად პოპულარული გახდა, დაახლოებით 6%-ით. ამავდროულად, TIOBE აჩვენებს, რომ C იყო ნომერ პირველი ენა 2002 წლამდე, ჯავა კი მე-14 ადგილზე იყო 1997 წელს, მაგრამ ხუთი წლის შემდეგ მან ჩაანაცვლა C პირველ პოზიციაზე.

თქვენ შეგიძლიათ წაიკითხოთ შესანიშნავი ლექცია ენების განვითარების ისტორიაზე: Yandex-ის აკადემიური პროგრამების კურატორი, ეკონომიკის უმაღლესი სკოლის კომპიუტერული მეცნიერების ფაკულტეტის სტუდენტური კონკურსების ცენტრის დირექტორი საუბრობს იმაზე, თუ როგორ ენები C გამოჩნდა PHP, Ruby და Java. მიხაილ გუსტოკაშინი. ლექტორი ხაზს უსვამს, რომ თითოეული ამოცანისთვის განსხვავებული პროგრამირების ენა უნდა შეირჩეს. მაგალითად, ის ამბობს, რომ სამხედრო ინდუსტრიისთვის უმჯობესია დაწეროთ ძველი პასკალი - ენა, რომელიც დაიბადა 1970 წელს! რატომ? იმიტომ რომ უფრო საიმედოა. ბიზნეს აპლიკაციები შეიძლება დაიწეროს Java-ზე, რადგან ეს ენა ასევე საკმაოდ საიმედოა, მაგრამ ბევრად უფრო ადვილი გამოსაყენებელი. ექსპერტი ასევე ხაზს უსვამს, რომ მნიშვნელოვანია პროგრამისტებს შორის ენისადმი ინტერესის შენარჩუნება ამ ენაზე დაწერილი დეველოპერების საზოგადოების შექმნით. თუ ახალი ენის ირგვლივ შეიქმნება ინფრასტრუქტურა და ხალხი შეიკრიბება მის გამოსაყენებლად, მხოლოდ მაშინ გახდება ეს ენა პოპულარული. სხვათა შორის, კოტლინის დეველოპერებმაც მიიღეს ეს სტრატეგია.

ცოტა კოტლინზე

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

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

« განვითარების ინსტრუმენტები, მათ შორის პროგრამირების ენები, მუდმივად ვითარდება. ენები განსხვავდება სხვა ინსტრუმენტებისგან იმით, რომ მათი განვითარება საკმაოდ რთულია ევოლუციურად. ენის ახალ ვერსიას უნდა ჰქონდეს ყველა არსებული პროგრამის მხარდაჭერა. ეს ზღუდავს არსებული ენების განვითარების შესაძლებლობებს და ქმნის ახლის გაჩენის აუცილებლობას. ფაქტორი, რომელიც განაპირობებს ახალი პროგრამირების ენის წარმატებას, უპირველეს ყოვლისა, კომფორტია დეველოპერებისთვის. გარდა იმისა, რომ ლაკონური და გამომხატველია, კოტლინი ძალიან თავსებადია ჯავის კოდთან: შეგიძლიათ გამოიყენოთ ყველა არსებული ბიბლიოთეკა და ერთ პროექტშიც კი შეურიოთ კოდი ორ ენაზე, ასე რომ არ არის განსაკუთრებული გადასვლის სირთულეები.”- თქვა კოტლინის პროექტის მენეჯერმა JetBrains-ში, ITMO უნივერსიტეტის კურსდამთავრებულმა.

რატომ უყვარდა Google-ს კოტლინი

ოფიციალურ ვებსაიტზე ანდროიდის დეველოპერები წერენ, რომ ბოლო წლებში კოტლინის „აწევას“ აკვირდებოდნენ. Google-ის თანამშრომლებს არ ერიდებათ ენის აღწერა, როგორც შთამბეჭდავი, ლაკონური, გამაძლიერებელი და სასიამოვნო სამუშაოდ. მან გაზარდა პროდუქტიულობა: მასში არსებული პროგრამის კოდი საშუალოდ 40%-ით უფრო მოკლეა, ვიდრე სხვა ენებზე და კოტლინი ასევე საშუალებას გაძლევთ თავიდან აიცილოთ გარკვეული შეცდომები კოდში. Google-ში კოტლინის პოპულარობის ერთ-ერთი განმსაზღვრელი ფაქტორი იყო ის, რომ ის თავსებადია Java-სთან, რომელიც უკვე გამოიყენება Android-ისთვის აპლიკაციების შემუშავებაში.

ახლა, როდესაც პროგრამისტები იწყებენ ახალი აპლიკაციის შექმნას ოფიციალურ Android Studio-ს განვითარების გარემოში, მათ შეუძლიათ დაუყოვნებლივ ჩართონ „Kotlin support“ მოდული. თქვენ ასევე შეგიძლიათ დააკონვერტიროთ უკვე შექმნილი კოდის ხაზები სხვა ენებზე კოტლინ ენაზე, ჩასვათ ბლოკები სხვა ენებზე კოდის ხაზებად კოტლინში. მომავალში შეიქმნება უფრო მეტი ბიბლიოთეკა და ინსტრუმენტები ენისთვის, შეიქმნება მეტი სასწავლო მასალა და გაადვილდება შესაძლო პრობლემების გადაჭრის გზები.

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

მან დასძინა, რომ კოტლინი ძალიან აქტიურად ვითარდება. დეველოპერების გუნდი ამჟამად მუშაობს build სისტემაზე, კომპილაციის სიჩქარეზე, IDE მუშაობის გაუმჯობესებაზე, ინსტრუმენტთა ნაკრების ახალი ფუნქციების დამატებაზე, მათ შორის Android Studio-ში ინტეგრაციასთან დაკავშირებული. ასევე მიმდინარეობს მუშაობა მულტიპლატფორმულ პროექტებზე (იგივე კოდის შედგენის შესაძლებლობა რამდენიმე პლატფორმისთვის) და არაერთი ენის გაუმჯობესება დიზაინის ეტაპზეა.

Google-მა ასევე ხაზგასმით აღნიშნა, რომ ისინი შთაგონებულია კოტლინის ენის კონცეფციით, რომლის მიხედვითაც ის ყოველთვის იყო და დარჩება უფასო დეველოპერებისთვის, ანუ ღია კოდის პროექტი. ეს ნიშნავს, რომ ენა არ არის მიბმული რომელიმე კონკრეტულ კომპანიასთან და წყაროს კოდი ნაწილდება უფასო ლიცენზიით. შეგიძლიათ ჩამოტვირთოთ პროდუქტი. Kotlin-ის განვითარების მხარდასაჭერად Google და JetBrains შექმნიან არაკომერციულ პარტნიორობას. ასევე, როგორც Android-ის „მისიის“ ნაწილი, ძალიან მნიშვნელოვანია, რომ Kotlin-ის ავტორებმა თავიანთი პროდუქტის ირგვლივ შექმნან ადამიანების საზოგადოება, რომლებიც პროფესიონალურად არიან ჩართულნი ამ ენის განვითარებაში და უყვართ თავიანთი გამოცდილების გაზიარება. მაგალითად, ნოემბერში კოტლინის კონფერენცია გაიმართება შეერთებულ შტატებში და დეველოპერებს ასევე შეუძლიათ მიიღონ ყოველდღიური სიახლეები და რჩევები პროგრამული პროდუქტის შესახებ და შეხვდნენ ადგილობრივად.

სხვათა შორის, თავად Android Studio პროექტი შეიქმნა IntelliJ IDEA პროგრამული უზრუნველყოფის განვითარების გარემოს საფუძველზე, რომელიც ასევე შეიქმნა JetBrains-ის მიერ. მაგრამ მჭიდრო თანამშრომლობის მიუხედავად, პეტერბურგის კომპანია ხაზს უსვამს, რომ ამერიკული IT გიგანტისთვის JetBrains-ის რაიმე გაყიდვაზე საუბარი არ არის. ამავდროულად, Koltin არ იქნება მხოლოდ Android-ისთვის განკუთვნილი. კომპანიის მიზანია გახადოს პროგრამირების ენა შესაფერისი განვითარების სხვადასხვა პლატფორმისთვის.

ბოლო განახლება: 12/02/2017

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

კოტლინი მუშაობს Java ვირტუალურ მანქანაზე (JVM) და კომპილირებულია ბაიტეკოდში შედგენისას. ანუ, როგორც ჯავის შემთხვევაში, ჩვენ შეგვიძლია გავატაროთ Kotlin აპლიკაცია ყველგან, სადაც JVM არის დაინსტალირებული. თუმცა ასევე შესაძლებელია კოდის შედგენა JavaScript-ში და მისი გაშვება ბრაუზერში. გარდა ამისა, თქვენ შეგიძლიათ შეადგინოთ კოტლინის კოდი მშობლიურ ბინარებში, რომლებიც იმუშავებენ ყოველგვარი ვირტუალური მანქანის გარეშე. ამრიგად, პლატფორმების დიაპაზონი, რომლებისთვისაც შეგიძლიათ Kotlin-ში აპლიკაციების შექმნა, ძალიან ფართოა - Windows, Linux, Mac OS, iOS, Android.

ენის პირველი ვერსია გამოვიდა 2016 წლის 15 თებერვალს. მიუხედავად იმისა, რომ თავად ენის განვითარება განხორციელდა 2010 წლიდან. ამ დროისთვის ენის მიმდინარე ვერსია არის ვერსია 1.2, რომელიც გამოვიდა 2017 წლის 28 ნოემბერს.

კოტლინმა მრავალი ენების გავლენა მოახდინა: Java, Scala, Groovy, C#, JavaScript, Swift და გაძლევთ საშუალებას დაწეროთ პროგრამები როგორც ობიექტზე ორიენტირებულ, ასევე ფუნქციურ სტილში. მას აქვს მკაფიო და გასაგები სინტაქსი და საკმაოდ მარტივი შესასწავლია.

ყველაზე პოპულარული ზონა, სადაც Kotlin გამოიყენება, ძირითადად არის Android OS-ის განვითარება. უფრო მეტიც, იმდენად პოპულარულია, რომ Google-მა Google I/O 2017-ის კონფერენციაზე კოტლინი გამოაცხადა Android-ის განვითარების ერთ-ერთ ოფიციალურ ენად (ჯავასთან და C++-თან ერთად), ხოლო ამ ენასთან მუშაობის ინსტრუმენტები ნაგულისხმევად შედიოდა ფუნქციონირებაში. Android Strudio-ს განვითარების გარემოს 3.0 ვერსიიდან დაწყებული.

თქვენ შეგიძლიათ გადმოწეროთ შემდგენელი პირდაპირ კოტლინის ენისთვის.

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

ახლა მოდით განვსაზღვროთ დირექტორია მყარ დისკზე საწყისი კოდის ფაილებისთვის. მაგალითად, ჩემს შემთხვევაში დირექტორია განთავსდება c:/kotlin ბილიკის გასწვრივ. მოდით შევქმნათ ტექსტური ფაილი ამ დირექტორიაში და გადავარქვათ სახელი app.kt. kt გაფართოება არის ფაილების გაფართოება კოტლინის ენაზე.

სახალისო მთავარი (არგ: მასივი ) (println ("გამარჯობა კოტლინ") )

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

ეს ფუნქცია იღებს args პარამეტრს, რომელიც წარმოადგენს სტრიქონების მასივს.

მთავარი ფუნქციის შიგნით შესრულებულია კიდევ ერთი ფუნქცია - println(), რომელიც ბეჭდავს გარკვეულ შეტყობინებას კონსოლში.

მოდით გავხსნათ ბრძანების ხაზი. პირველი, გამოიყენეთ cd ბრძანება საქაღალდეში გადასასვლელად, სადაც app.kt ფაილი მდებარეობს. შემდეგ პროგრამის კომპილაციისთვის შეიყვანეთ შემდეგი ბრძანება:

C:\kotlin\bin\kotlinc app.kt -include-runtime -d app.jar

ამ შემთხვევაში app.kt ფაილს გადავცემთ კომპილატორს c:\kotlin\bin\kotlinc კომპილაციისთვის. (იმისთვის, რომ არ დაწეროთ სრული გზა შემდგენელზე, შეგიძლიათ დაამატოთ მას გზა გარემოს ცვლადებში PATH ცვლადში). შემდეგი, -include-runtime პარამეტრის გამოყენებით, თქვენ მიუთითებთ, რომ გენერირებული ფაილი მოიცავს Kotlin გარემოს. და -d პარამეტრი განსაზღვრავს რა ერქმევა შექმნილ აპლიკაციის ფაილს, ანუ ამ შემთხვევაში ეს იქნება app.jar .

ამ ბრძანების გაშვების შემდეგ შეიქმნება app.jar ფაილი. ახლა მოდით გავუშვათ. ამისათვის შეიყვანეთ ბრძანება

ჯავა -jar app.jar

ამ შემთხვევაში, ვარაუდობენ, რომ კომპიუტერზე დაინსტალირებული JDK-ისკენ მიმავალი გზა მითითებულია PATH ცვლადში გარემოს ცვლადებში. წინააღმდეგ შემთხვევაში, "java"-ს ნაცვლად, თქვენ მოგიწევთ ჩაწეროთ ჯავას პროგრამის სრული გზა.

შედეგად, ფაილის გაშვებისას, კონსოლზე დავინახავთ ხაზს "Hello Kotlin".

2010 წელს, JetBrains-ის რუსული ფილიალის დეველოპერთა ჯგუფმა შეუდგა ენის შემუშავებას, რომელიც უფრო მოსახერხებელი და უსაფრთხო იქნებოდა ვიდრე Java, მაგრამ არა ისეთი რთული, როგორც Scala. ამ ენის სახელი ეწოდა კუნძულ კოტლინს, რომელიც მდებარეობს ფინეთის ყურეში (იავას ანალოგიით, რომელსაც ასევე კუნძულის სახელი ჰქვია).

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

სინტაქსი

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

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

თუმცა, ჩვენ მაინც დავტოვებთ კოდის მცირე ნაწილს:

სახალისო მთავარი (არგ: მასივი ) {
val scope = "სამყარო"
println ("გამარჯობა, $scope!")
}

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

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

უპირატესობები

ზოგადად, ჯავასთან შედარებით ყველა უპირატესობა უკვე აღინიშნა, ასე რომ, ჩვენ მათ მხოლოდ ერთ ადგილას ვაგროვებთ:

კოდის მოცულობა. კოდის არასაჭირო არქაული ნაწილების გამოუყენებლობა აჩქარებს განვითარების პროცესს და ზრდის კითხვადობას;

უსაფრთხოება. ენის სინტაქსში ჩადებული კოდის შექმნის წესები საშუალებას გაძლევთ თავიდან აიცილოთ მცირე, ძნელად აღრიცხვადი შეცდომები, რომლებიც წარმოიქმნება მხოლოდ პროგრამის შესრულების დროს;

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

ხარვეზები

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

კოტლინი, ამ დროისთვის, უმკლავდება თავის მთავარ ამოცანებს და ჯავას სრული თავსებადობა გვეხმარება თვალის დახუჭვაში ამ ხარვეზებზე.

პერსპექტივები

იმისდა მიუხედავად, რომ კოტლინის განვითარება დაიწყო 2010 წელს, პირველი ოფიციალური ვერსია გამოვიდა მხოლოდ 2016 წლის თებერვალში. მას შემდეგ ენაზე მოთხოვნა სწრაფად იზრდებოდა, TIOBE რეიტინგში ის ერთ წელიწადში TOP-50-ში მოხვდა. და გასულ თვეში Google I კონფერენციაზე /O გამოაცხადა ოფიციალური მხარდაჭერა Kotlin-ისთვის Android აპლიკაციების განვითარების სისტემაში.

IntelliJ IDEA-ს მაღალი პოპულარობის გათვალისწინებით დეველოპერებს შორის და კომპანიის სტრატეგიული აქცენტის Kotlin-ზე, თამამად შეგვიძლია ვთქვათ, რომ 3-4 წელიწადში მას ვიხილავთ Java-სა და Swift-ის სრულფასოვან კონკურენტებს შორის მობილური განვითარების სფეროში. გარდა ამისა, თუ ენის შემქმნელები არ არიან იმედგაცრუებული თავიანთი პროდუქტით, კოტლინი აუცილებლად გააგრძელებს სხვა ჰორიზონტებს: ვებ, AI, ნივთების ინტერნეტი, დიდი მონაცემები, დესკტოპის აპლიკაციები.

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