Файл: «Современные языки программирования» . ..pdf

Переменные в Go объявляются с использованием ключевого слова, var как показано ниже:

var s string
s = "Welcome to Go"

Конечно, декларация и инициализация могут выполняться в одно и то же время:

var s string = "Welcome to Go"

Go также предлагает более короткий способ объявления переменных, как показано ниже:

s := "Welcome to Go"

В этом случае компилятор Go будет выводить ' s ' как a string.

Как уже упоминалось, параллелизм - это одна из областей, в которой Go сияет больше всего. Go использует goroutines и каналы для реализации параллелизма.

Ниже приведен простой пример:

func main() {
c1 := make(chan string)
c2 := make(chan string)

go func() {
for {
c1 <- "hello from channel 1"
}
}()

go func() {
for {
c2 <- "hello from channel 2"
}
}()

go func() {
for {
select {
case msg1 := <- c1:
fmt.Println(mg1)
case msg2 := <- c2:
fmt.Println(mg2)
default:
fmt.Println("Nothing is ready yet.")
}
}
}()

var input string
fmt.Scanln(&input)
}

Goroutine объявляется с помощью go ключевого слова. Горутины - это потоковые объекты, которые могут выполняться одновременно. Горутины общаются по каналам .

Тип канала указывается ключевым словом, chan за которым следует тип «трафика», который будет обрабатывать канал, как показано ниже:

c1 := make(chan string)

В этом случае мы используем встроенную make функцию для создания канала c1 , который может обрабатывать трафик string типа.

Оператор левой стрелки ( <- ) используется для отправки (и приема) сообщений по каналу, как показано ниже:

c1 <- "hello from channel 1"

В этом случае строковое сообщение « привет от канала 1 » является « отправить » на канал c1 .

Конструкция приема показана ниже:

msg1 := <- c1

Вышеприведенный фрагмент кода может быть интерпретирован как:

« Получать сообщение от канала c1 и хранить его в msg1 ».

Блок выбора выбирает первый канал, который готов, и получает от него сообщение. Если более одного из каналов готовы, тогда он случайным образом выбирает, какой из них будет получать. Если ни один из каналов не готов, оператор ожидает, пока канал станет доступным (процесс, обычно известный как блокирование ). Но если предоставлен случай по умолчанию , тогда он будет выполнен вместо этого.

Самым известным проектом, реализованным с помощью Go, является, возможно, Docker - программная технология для создания контейнеров .

3.1.3 Rust

Rust - это язык системного программирования, который был создан Mozilla Research как более безопасная и эффективная альтернатива C / C ++. Он был официально выпущен в качестве проекта с открытым исходным кодом еще в 2010 году. Ведущим разработчиком этого языка был Грейдон Хоар , который с тех пор переехал в Apple и теперь работает как часть команды Swift (обсуждается позже).

Заявленные цели языка программирования Rust:

• безопасности
• скорость
• совпадение

Из этих трех, Rust использует безопасность наиболее серьезно. Он обеспечивает безопасность посредством одной из самых уникальных (и сложных) концепций: права собственности. 

Простое объявление функции в Rust выглядит так:

fn factorial(x: i32) -> i32 {

// The body of the function goes here....

}

Функция в Rust объявляется с использованием ключевого слова fn. За этим следует имя функции и список аргументов в паре круглых скобок. В приведенном выше случае у нас есть только один аргумент x , который представляет собой 32-разрядное integer число со знаком. Обратите внимание, что тип аргумента функции должен быть объявлен; и если есть несколько аргументов, они должны быть разделены запятыми.

Функция возвращает другое 32-разрядное целое число со знаком, указанное указателем правой стрелки ( -> ) и i32 после него.

Переменные в Rust неизменяемы по умолчанию (безопасность берется очень серьезно в Rust!), И они объявляются с использованием ключевого слова let, как показано ниже:

let x = 7;

Вышеприведенный код объявляет локальную переменную и присваивает ей значение 7 . Фрагмент кода официально называется привязкой переменной в Rust. В этом случае 7 « привязано » к переменной x. Компилятор Rust выберет тип x as i32.

Идея переменных привязок позволяет сопоставить шаблоны, как показано ниже:

let (x, y) = (7, 13);

В этом случае 7 будет привязано к х и 13 к у .

Тип переменной может быть явно объявлен, как показано ниже:

let x: i32 = 7;

Если переменная должна измениться после ее инициализации, мы должны добавить ключевое слово mut(изменяемое) следующим образом:

let mut x = 7;

В отличие от большинства других рассмотренных языков, Rust требует точку с запятой в качестве терминатора утверждения (хотя для этого правила существует несколько исключений).

Будучи системным языком, Rust предлагает собственные примитивы параллелизма на уровне потока. Он обещает « параллелизм без гонок данных ».

Темы в Rust создаются с использованием следующего синтаксиса:

let thread = std::thread::spawn(|| {
println!("Graydon");
});

Чтобы создать новый поток, мы используем spawn()функцию из стандартной библиотеки потоков: std :: thread .

spawn() Функция принимает в качестве аргумента замыкания , которое в этом случае печатает string.

Следует обратить внимание на bang ( ! ) В конце println . Это означает, что это macro вызов, а не обычный вызов функции.

Как и в Go, потоки в Rust взаимодействуют через каналы . Это иллюстрируется следующим примером:

use std::thread;
use std::sync::mpsc;

fn main() {
let (tx, rx) = mpsc::channel();

for _ in 0..10 {
let tx = tx.clone();

thread::spawn(move || {
let result = 77u32;

tx.send(result);
});
}

rx.recv().ok().expect("could not receive the result.");
}

Сначала идет импорт стандартных потоков и sync библиотек synchronization ( ).

Канал создается путем вызова channel() метода из пакета std :: sync :: mpsc , как показано ниже:

let (tx, rx) = mpsc::channel();

В этом случае канал связан с кортежем арностью 2 (Arity относится к числу аргументов операция занимает).

Инициалы в mpsc означают « множественный производитель, один потребитель» . Это означает, что « отправляющий » конец канала (в данном случае tx ) может быть клонирован (копии его могут быть сделаны) и использоваться таким количеством потоки, как вы хотели бы присвоить значения; но « приемный » конец канала (в данном случае, rx ) не может быть клонирован, поэтому только один поток может извлекать значения из очереди.

После создания потока он вычисляет результат и отправляет его по каналу через tx , как показано ниже:

tx.send(result);

В примере используется move замыкание при создании потока. Это обеспечивает право собственности , предоставляя закрытию собственный стек стека .

Если rx получает результат , expect метод возвращает значение результата, иначе он возвращает ошибку Err(e), со строковым сообщением: « не смог получить результат ».

Стандартный пакет синхронизации Rust ( std :: sync ) предлагает еще два типа, которые полезны для обеспечения безопасности в многопоточной среде: Mutex<T> и Arc<T>. Чтобы использовать их, их необходимо импортировать, как показано ниже:

use std::sync::Mutex;
use std::sync::Arc;

Вышеупомянутый импорт также может быть выполнен с использованием только одной строки, например:

use std::sync::{Mutex, Arc};

Тип Mutex предлагает блокировки через свой lockметод. Это гарантирует, что два потока не могут требовать владения одной и той же частью данных одновременно.

Инициалы в Arc обозначают « Atomic reference count ». Тип Arc гарантирует, что совместное использование неизменяемых данных является потокобезопасным . Он пытается избежать расчётов данных между несколькими потоками.

Наконец, Rust предлагает надежный менеджер пакетов под названием Cargo . Это помогает в управлении внешними кодовыми библиотеками Rust (теми, которые не входят в стандартную библиотеку), известными как « ящики » сообщества Rust.

Следующий фрагмент кода показывает, как вы можете использовать вызванный библиотечный ящик rand, который предлагает функциональность случайных чисел:

extern crate rand;

extern

Ключевое слово указывает на то, что это внешняя библиотека ( обрешетка ).

Другая область, в которой Rust отличается, - это поддержка FFI(Интерфейс внешних функций). Это означает, что его можно легко встроить в другие языки.

С точки зрения его кривой обучения, Rust лежал бы чуть ниже Scala .

Следует упомянуть, что согласно опросу разработчиков стека Overflow , Rust был самым любимым языком программирования в течение двух лет подряд (2016 и 2017).

3.1.4 Kotlin

До недавнего времени Котлин был едва известен в рамках большого сообщества разработчиков. Язык, названный в честь острова Котлинвблизи Санкт-Петербурга в России, был создан компанией JetBrains , компанией популярных продуктов, таких как IntelliJ IDEA, PhpStorm и PyCharm . Он был официально выпущен в 2011 году, и он работает поверх виртуальной машины Java (аналогично Scala ).

Kotlin получил очень большой импульс, когда в выпуске ввода-вывода Google в 2017 году было объявлено, что языку была оказана первоклассная поддержка на мобильной платформе Android (став только третьим языком, которому будет предоставлен такой статус, после Java и C ++ ). Новость была получена с большим волнением со стороны сообщества разработчиков Android. В результате интерес к этому языку резко возрос в течение последних нескольких месяцев после объявления. Кроме того, это может рассматриваться как стратегический шаг Google, поскольку он был вовлечен в юридическую борьбу с Oracle за использование определенных классов Java для Android.

Одна из заявленных целей Kotlin заключается в том, чтобы полностью взаимодействовать с Java и работать так же быстро, как собственный код Java.

Простая декларация функции в Kotlin выглядит так:

fun factorial(x: Int): Int {

// The body of the function goes here...

}

Этот блок кода очень похож на код Scala, показанный ранее, и поэтому он не требует большого объяснения. Единственное, что нужно отметить здесь, это то, что в Котлине функция объявляется с использованием ключевого слова fun. В этом случае функция принимает один аргумент типа Intи возвращает Int также.

Как и в Scala, переменные в Kotlin объявляются с использованием либо val или var ключевых слов, как показано ниже:

val x: Int = 3
var y = 7

В этом случае x является неизменной переменной типа Int, а y изменчива. Тип y определяется как Int.

По сравнению с тремя языками, рассмотренными выше, я считаю, что реализация параллелизма в Котлине является наименее надежной.

Kotlin использует сопрограммы для реализации параллелизма (хотя в последний раз, когда я проверял, он все еще находился на экспериментальной фазе). Он применяет концепцию подвески , что означает, что вычисления могут быть приостановлены без блокировки рабочей нити.

Вот несколько причин, почему можно полностью переключиться на Kotlin:

• Kotlin на 100% совместим с Java . Вы можете буквально продолжить работу над старыми Java-проектами, используя Kotlin. Все ваши любимые фреймворки Java по-прежнему доступны , и любые рамки, которые вы будете писать в Kotlin, легко принимаются вашим упрямым другом, любящим Java.
• Котлин - не какой-то странный язык, родившийся в академических кругах. Его синтаксис знакомы любому программисту, поступающему из домена ООП , и его можно более или менее понимать с самого начала. Конечно, есть некоторые отличия от Java, такие как переработанные конструкторы или val var объявления переменных. 
• Компилятор Kotlin отслеживает логические и автоматические типы, если это возможно , что означает, что больше никаких instanceof проверок не следует явным приведениям.
• Нет необходимости определять несколько подобных методов с различными аргументами.
• В сочетании с аргументами по умолчанию именованные аргументы устраняют необходимость в сборщиках и др.

3.1.5 Swift

Swift - мощный и интуитивно понятный язык программирования для macOS, iOS, watchOS и tvOS. Написание кода Swift является интерактивным и забавным, синтаксис является сжатым, но выразительным, а Swift включает в себя современные функции, которые разработчики любят. Быстрый код безопасен по дизайну, но также производит программное обеспечение, которое работает молниеносно.

Созданный в Apple, Swift предназначен для более безопасной и более сжатой альтернативы Objective-C для разработки приложений в экосистеме Apple. Язык был представлен на Всемирной конференции разработчиков Apple в 2014 году и выпущен в качестве проекта с открытым исходным кодом год спустя. Его ведущим дизайнером был Крис Лэттнер (который также является одним из оригинальных авторов проекта LLVM ).

Swift является результатом последних исследований по языкам программирования в сочетании с многолетним опытом создания платформ Apple. Именованные параметры, перенесенные из Objective-C, выражаются в чистом синтаксисе, который упрощает чтение и обслуживание API в Swift. Выведенные типы делают код более чистым и менее подверженным ошибкам, тогда как модули исключают заголовки и предоставляют пространства имен. Память управляется автоматически, и даже не нужно вводить полуколоны. Эти перспективные концепции приводят к легкому и интересному языку.

Большая часть кода Swift немного похожа на код, написанный в Rust.

Простая декларация функции в Swift написана, как показано ниже: