Scala как первый язык

Эта статья, как и мой предыдущий пост, не похожа на то, что обычно публикуют на Хабре.  Здесь не объясняется никаких новых или старых концепций, я не рассказываю что такое ООП и функциональное программирование, сложного кода почти нет. Я хочу пригласить вас к дискуссии стоит ли начинать программировать с языка Scala.

Меня иногда просят научить программированию или помочь с поиском подходящего курса. Я хорошо понимаю недостатки и сложности со скалой, но думаю, что Scala 3 — подходящий язык, для того чтобы начать обучение с него, если правильно составить курс. Вся языковая мощь и сложность, конечно, не нужны начинающему программисту, но ему и незачем о них знать. На скале можно писать вполне простой и понятный код, постепенно наращивая инструментарий.

Я согласен с теми комментаторами, кто считает что для этого нужен толковый преподаватель. Это безусловно. Или талантливый преподаватель, который разбирается в предмете, или хорошая книжка, или толковый курс просто необходимы. Иначе есть риск захлебнуться, так и не научившись плавать.

И тем не менее я считаю, что Scala — это язык будущего.

Итак, почему я люблю скалу, считаю ее языком будущего и думаю что с нее можно начинать изучение программирования?

Умный компилятор

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

Я люблю говорить, что джава — это язык для компилятора, а скала — это язык для программиста.

JVM-экосистема

Как известно, Джеймс Гослинг, создатель языка джава, считает самой лучшей ее частью джава-машину. Действительно, много инженеров потратило десятки человеко-лет на разработку виртуальной машины и достигли скоростей, в некоторых случаях превышающих Си++. Вот исследование производительности JVM в мобильных устройствах, в нем чаще побеждает нативный код на Си, но в одном случае победила JVM: Java vs C app performance.

Модель памяти для многопоточных вычислений JVM — это зрелая, непротиворечивая, проверенная многими годами промышленного программирования парадигма, которая при правильном использовании гарантирует достаточный уровень абстракции и безопасности. Благодаря этому возможны удобные конструкции для параллельного программирования, доступные даже начинающим.

Кроме того, на джаве написаны миллионы строк кода, которые вы можете использовать из скалы или без проблем в нее транслировать.

Кстати, Джеймсу Гослингу скала тоже нравится.

Но в этом всем есть и минусы. Как мы знаем, верхнеуровневые абстракции протекают, и для того чтобы программировать на скале, важно знать как устроена виртуальная машина джава, и учитывать ее особенности. Например, такие как Type Erasure.

Эволюция vs революция

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

Но с другой стороны такой подход обеспечивает быстрое и динамичное развитие языка, которое не может себе позволить джава. Именно поэтому я думаю что будущее — за скалой.

К тому же, в Scala 3 появилось типизированное абстрактное синтаксическое дерево компилятора TASTY, которое позволит взаимодействовать классам, собранным разными версиями компилятора. Разумеется, начинающим программистам нет нужды разбираться в этом.

Scala 3

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

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

Но некоторые решения, принятые более 15 лет назад, были неверными и приводили к неочевидному, либо многословному коду. И сейчас создатели языка делают его действительно лучше. После этих изменений шансы скалы в качестве первого языка программирования заметно вырастают.

Я уже пару лет с нетерпением жду его выхода и мечтаю начать писать на нём. Вот сжатый рассказ Мартина Одерски про новую версию языка: Countdown to Scala 3 by Martin Odersky. Для опытных разработчиков — интересная статья Annoying things in Scala 2 that’ll be (mostly) gone in Scala 3

DOT

Dependent Object Types — это теоретические основы языка Scala 3, разработанные его основателем Мартином Одерски. Мало какой язык может похвастать математически точным исчислением, лежащем в его основе.

Согласитесь, приятно учить язык с таким бэкграундом, хотя начинающим программистам знать о нём не обязательно.

Выразительность и лаконичность

То, что я больше всего люблю в языке — это его сжатость и лаконичность. Я ненавижу длиннейшие конструкции джавы, в которых приходится сложно и многословно объяснять компилятору простые вещи. Моя любимая шутка про джаву, что это такой язык, в котором уан-лайнер занимает около 30 строк. Так вон в скале уан-лайнер — это уан-лайнер.

Я думаю, что это качество важно не только для опытных разработчиков, но и для тех кто только изучает язык, если оно не наносит ущерб читаемости кода.

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

Вот мой любимый пример для библиотечного кода на скале. Конечно, он не предназначен для начинающих разработчиков:

class Stack[+A] {

  def push[B >: A](elem: B): Stack[B] = new Stack[B] {
    override def top: B = elem
    override def pop: Stack[B] = Stack.this
    override def toString = s"$elem ${Stack.this}"
  }

  def top: A = sys.error("no element on stack")
  def pop: Stack[A] = sys.error("no element on stack")
  override def toString = ""
}

object VariancesTest extends App {
  println(Stack().push("hello").push(Object()).push(7))
}

Думаю, выразительность — это та причина, по которой так популярны динамические и скриптовые языки. Уверен, скала способна с ними в этом поспорить. И даже сама послужить отличным скриптовым языком.

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

enum IndentWidth:
  case Run(ch: Char, n: Int)
  case Conc(l: IndentWidth, r: Run)

  def <= (that: IndentWidth): Boolean = this match
    case Run(ch1, n1) =>
      that match
        case Run(ch2, n2) => n1 <= n2 && (ch1 == ch2 || n1 == 0)
        case Conc(l, r)   => this <= l
    case Conc(l1, r1) =>
      that match
        case Conc(l2, r2) => l1 == l2 && r1 <= r2
        case _            => false

  def < (that: IndentWidth): Boolean =
    this <= that && !(that <= this)

  override def toString: String = this match
    case Run(ch, n) =>
      val kind = ch match
        case ' '  => "space"
        case '\t' => "tab"
        case _    => s"'$ch'-character"
      val suffix = if n == 1 then "" else "s"
      s"$n $kind$suffix"
    case Conc(l, r) =>
      s"$l, $r"

object IndentWidth:
  private inline val MaxCached = 40

  private val spaces = IArray.tabulate(MaxCached + 1)(new Run(' ', _))
  private val tabs = IArray.tabulate(MaxCached + 1)(new Run('\t', _))

  def Run(ch: Char, n: Int): Run =
    if n <= MaxCached && ch == ' ' then
      spaces(n)
    else if n <= MaxCached && ch == '\t' then
      tabs(n)
    else
      new Run(ch, n)
  end Run

  val Zero = Run(' ', 0)
end IndentWidth

Статическая типизация

По-моему это самое важное что должно быть в первом языке программирования. Программисту важно понимать, что не стоит складывать яблоки с апельсинами.

Все в порядке с Питоном, Руби, Джаваскрипт, Си и Си++, но на мой взгляд не стоит начинать обучение с них. Динамическая типизация — это очевидный способ выстрелить себе в ногу.

Другое дело, что статическая типизация неудобна, неочевидна и требует дополнительного бойлер-плейта. Скала вполне успешно позволяет избавиться от него в простых программах.

ООП

Объектно-ориентированное программирование — это самая популярная парадигма, без которой не обходится не один современный язык программирования.

В скале эта парадигма изначально присуща языку, в отличии от Питона, Си/Си++ и в каком-то смысле джаваскрипта. Разумеется, сейчас у этих языков с ООП полный порядок.

Функциональное программирование

Функциональное программирование — это многообещающая тенденция. Скале она присуща в не меньшей степени чем ООП, и они взаимно обогащают друг друга благодаря этому языку. Рискну предположить, что скала — первый язык промышленного уровня с такими свойствами. Сейчас за ним подтягивается Котлин и другие более новые языки.

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

• Почему вы должны думать о функциональном программировании

• Почему разработчики влюбляются в функциональное программирование?

• Почему функциональное программирование такое сложное

Иммутабельность

Вообще-то это свойство функционального программирования. Мне кажется очень важным прививать умение пользоваться иммутабельными структурами данных с самого начала. Это позволит в будущем создавать безопасный многопоточный код. И не только многопоточный.

Расширяемость

Как известно, название языка изначально преподносилось как аббревиатура Scalable Language. Особенности языка позволяют писать гибкие и красивые DSL, удобные даже для не-программистов, вкладывать абстракции друг в друга, создавать очень удобные библиотеки и простые скрипты.

Это был последнее свойство языка, которое мне хотелось бы обсудить. Некоторые свойства отображены на картинке ниже.

Свойства языка Scala

Рынок вакансий

Конечно, вакансий для скала-программистов значительно меньше, чем для джава-программистов. Но зато Scala выше оплачивается.

Вот вам картинка про области применения скалы:

Мои первые книжки

Самая лучшая книжка про скалу, которую я читал — Scala by Example Мартина Одерски, написанная уже 10 лет назад. Прежде чем начинать сейчас читать книгу по скале, очень рекомендую убедиться что она обновлена до версии  Scala 3.

А любимый курс — это Functional Programming in Scala, я проходил его в самой первой версии, с тех пор он, конечно, успел измениться. Первые уроки этого курса основываются все на той же Scala by Example.

Если вы хотите поиграть скалой или дотти, не устанавливая IDE — добро пожаловать в Scastie.

Пример кода

Много примеров короткого кода на скале можно найти вот в этом обсуждении: Samples of Scala and Java code where Scala code looks simpler/has fewer lines? Вот один из них:

Scala

object Main extends App {
  val keywords = List("Apple", "Ananas", "Mango", "Banana", "Beer")
  val result = keywords.sorted.groupBy(_.head)
  println(result)
}

Java 8

import java.util.*;

class Main {
  public static void main(String[] args) {
    List<String> keywords = Arrays.asList("Apple", "Ananas", "Mango", "Banana", "Beer"); 
    Map<Character, List<String>> result = keywords.stream().sorted().collect(Collectors.groupingBy(it -> it.charAt(0)));
    System.out.println(result);
  }
}

Java 7

import java.util.*;

class Main {
  public static void main(String[] args) {
    List<String> keywords = Arrays.asList("Apple", "Ananas", "Mango", "Banana", "Beer"); 
    Map<Character, List<String>> result = new HashMap<Character, List<String>>(); 
    for(String k : keywords) {   
      char firstChar = k.charAt(0);     
      if(!result.containsKey(firstChar)) {     
        result.put(firstChar, new  ArrayList<String>());   
      }     
      result.get(firstChar).add(k); 
    } 
    for(List<String> list : result.values()) {   
      Collections.sort(list); 
    }
    System.out.println(result); 
  }
}

Поступь прогресса

На прощанье — шутка Кея Хорстмана «The March of Progress»

1980: C 

printf("%10.2f", x);

1988: C++

cout << setw(10) << setprecision(2) << fixed << x;

1996: Java

java.text.NumberFormat formatter = java.text.NumberFormat.getNumberInstance(); 
formatter.setMinimumFractionDigits(2); 
formatter.setMaximumFractionDigits(2); 
String s = formatter.format(x); 
for (int i = s.length(); i < 10; i++) System.out.print(' '); 
System.out.print(s);

2004: Java

System.out.printf("%10.2f", x);

2008: Scala and Groovy

printf("%10.2f", x)

2012: Scala 2.10

println(f"$x%10.2f")

На этом я рискну опубликовать этот пост, но по-прежнему планирую его дописывать по результатам обсуждения с вами.