Зачем нужен Scala?
Разбираем, почему это не самый популярный язык.
Встречали в вакансиях позицию разработчика на Scala? Это редкий зверь, но платят нормально. Разберёмся, что это такое и зачем нужно.
Разработчик языка рассчитывал, что Scala станет преемником Java: он наследует многое хорошее из Java, работает по схожим принципам и добавляет что-то своё. И хотя Scala не стал таким же распространённым, всё равно стоит понять, из чего он сделан.
Плюсы Scala
Scala, как и Java, работает под JVM — виртуальной машиной Java (Java Virtual Machine). JVM — это такая прослойка между программой и железом. Благодаря этой прослойке один и тот же код можно исполнить на чём угодно, для чего есть JVM: и на компьютере, и на терминале оплаты, и на умном холодильнике. Не нужно каждый раз думать: «А какие там драйверы экрана?» или «С какой скоростью работает сетевой шлюз?» — всё это берёт на себя JVM, а мы пишем только логику и интерфейс.
Минусы Scala
Но если всё было бы так просто, про Java все давно бы забыли, но этого не произошло. Более того, сейчас не так много Scala-вакансий на рынке, чтобы говорить о популярности этого языка. На это есть несколько причин:
Синтаксис
С точки зрения кода в Scala всё то же самое, что и в Java-языках, кроме некоторых ООП-особенностей, поэтому начнём с привычных деталей, а потом перейдём к отличиям.
Основы. Каждая команда заканчивается точкой с запятой, а присваивание и математические операторы такие же, как в Java и JavaScript.
Типов данных — много, как в любом типизированном языке. Как и в Ruby, каждый тип — это объект, который можно менять, добавлять в него новые методы.
Переменные. Объявляются с помощью служебных слов val и var, но разница между ними в Scala настолько размытая и непрозрачная, что иногда даже опытным разработчикам сложно понять, какое слово будет уместнее в каждой ситуации.
Условные операторы и циклы. Всё привычно — for, while и do-while, но с одним отличием: в цикле for применяется упрощённая запись для организации переменной цикла. Обратите внимание на код ниже — сколько танцев с бубном ради одного цикла, который сам занимает три строки (не считая комментария):
Кто и для чего использует Scala
У Scala нет явно выраженной области применения, как у некоторых других языков. С другой стороны, из-за объединения ООП и функционального программирования этот язык прижился в тех командах, которым нужно совмещать в работе оба подхода.
Второе преимущество — возможность запустить код в любом JVM-окружении, поэтому Scala выбирают те, кому нравится объектный подход, но не нравится то, как это сделано в Java.
Основные популярные фреймворки — Play и Lift, и их используют в основном СМИ и новостные сайты:
С чего начать
Если хотите изучить основы Scala и попробовать свои силы в объектно-ориентированном программировании в мире Java, то вот с чего можно начать.
Большая статья в RSDN Magazine — «Обзор языка программирования Scala». Хороший и понятный материал, но подан в сухом академическом стиле.
«Scala в примерах» в Викиучебнике — написано попроще, но без введения для новичков.
«Руководство по Scala» в Записках задумчивого программиста — просто, понятно, но иногда автор не даёт подробных объяснений тому, что происходит в коде.
Scala. Введение
Не так давно я заинтересовался одним из многочисленных ныне языков под JVM — Scala. Причин тому много, основная — всё нарастающее со временем чувство неудобства при работе с cpp-подобными языками. Взгляд мой попеременно падал на Ruby, Groovy, Python, но все они оставляли впечатление инструментов, не совсем подходящих для моего обычного круга рабочих задач (Python-таки хорош, но у нетипизированных языков есть свои ограничения). Scala же, напротив, показалась вполне годным языком. Так как поиск по хабру никаких статей о ней не выловил (было несколько, но мягко говоря не вводных), я решил написать маленький обзор и поделиться им с массами.
Немного философии языка в вольном изложении
Какие основные цели преследовали создатели языка? Согласно моим мироощущениям они такие:
Во-первых, совместимость. Среди своих задач разработчики ставили поддержание совместимости с Java-языком и тысячами примеров говнокода разработок на ней для решения самых разнообразных задач.
Во-вторых, интенсивное насыщение языка функциональными фичами, которые, в основном, (но далеко не полностью) составляют его отличия от Java.
В-третьих, облегчение нашего с вами труда. Действительно, компилятор Scala понимает программиста с полуслова, писать код специально, чтобы втолковывать ему, что я не верблюд, мне не довелось пока.
В-четвёртых, поддержка и стимулирование написания модульных, слабосвязанных программных компонентов в сочетании с широкими возможностями адаптации уже существующих. Цели не то, чтобы совсем противоположные, но порождающие известные трудности для одновременного достижения. Что ж, посмотрим что получится.
В-пятых, это поддержка параллелизма. К сожалению у меня руки и голова до этой области не дошли (надеюсь пока), но акцент на этом моменте делается постоянно на всех ресурсах по языку.
Для экспериментов с языком достаточно поставить соответствующий плагин на любимую IDE отсюда.
Итак, давайте посмотрим на сам язык…
Общие идеи языка, примеры синтаксиса
Самое, пожалуй, важное, — это «унифицированная модель объектов». Этот термин расшифровывается авторами так: «каждое значение — объект, каждая операция — вызов метода». Это, конечно, не «всё — объект», но сущностей в сравнении с Java убыло, а чем меньше сущностей — тем легче жизнь 
В прикладном плане это означает, что числа и символы сделались неизменяемым объектами, обитающими в общей куче, все операции приобретают ссылочную семантику. Например, код 5 + 5 вполне валиден, и породит новый объект в куче, который оперативненько оприходует сборщик мусора (на самом деле, я тихо надеюсь, что компилятор поймёт глубину замысла и порождать он ничего не будет ).
После столь возвышенного введения можно глянуть на решение классической задачи:
println( ( «Hello, » + args(0) + «!» ).toUpperCase )
println( «Hello, » + args(0) + «!» toUpperCase )
В качестве подспорья разработчику Scala поддерживает также интерактивный режим. То есть, можно запустить интерпретатор и по одной вводить комманды. Интерпретатор, встроенный в IDE, как-то нерегулярно работает, его отдельный вариант есть в репозитариях Убунты, думаю у остальных дистрибутивов тоже всё хорошо, счастливым обладателям Windows как всегда придётся помучаться Интерпретатор запускается самым необычным способом:
$ scala
Welcome to Scala version 2.7.3final (Java HotSpot(TM) Server VM, Java 1.6.0_16).
Type in expressions to have them evaluated.
Type :help for more information.
scala>
Совсем маленький пример:
scala> 1 to 10
res0: Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
Тут мы видим пример вызова метода с параметром. Если кто не догадался, у объекта класса Int 1 вызывается метод to с параметром того же типа 10, результат — диапазон значений.
Операции над функциями
Что же мы такого можем с ними тут делать? Да что угодно =) Функции являются полноценными объектами программы. Их можно хранить как свойства объектов, передавать как параметры и возвращаемые значения и собственно создавать во время выполнения. Данные свойства позволяют строить так называемые функции высокого порядка, оперирующие себе подобными.
Для иллюстрации рассмотрим ставший классическим пример вычисления суммы:
scala> def sum(f: Int => Int, a: Int, b: Int): Int =
| if (a > b) 0 else f(a) + sum(f, a + 1, b) sum: ((Int) => Int,Int,Int)Int
В данном примере определяется функция sum, представляющая знакомый, надеюсь, всем оператор суммы. Параметры имеют следующий смысл:
f — функция преобразования целого числа из пределов суммирования в элемент суммы. Обратите внимание на объявление типа параметра: знак => означает, что параметр — функция, типы принимаемых значений перечисляются слева от него в круглых скобках (если параметр один, как в данном примере, их допустимо опустить), тип возвращаемого результата справа.
Работает она тривиально: вычисляет значение функции в нижней границе диапазона и складывает его с результатом вычисления себя самой в диапазоне на 1 меньшем.
Также в этом примере видна ещё одна особенность языка — if является выражением, имеющим значение (кстати, использованный ранее for — тоже выражение, его результат типа Unit ). Если условие истина, то его результат первый вариант, иначе — второй.
a и b — пределы суммирования.
Теперь можно воспользоваться тем, что мы написали ранее.
scala> sum(id, 1, 5)
res1: Int = 15
scala> sum(square, 1, 5)
res2: Int = 55
Здесь происходит кульминация этой части — мы берём и передаём функцию в другую функцию. Никаких интерфейсов, анонимных классов, делегатов: вот оно — маленькое счастье.
Я здесь намеренно не стал приводить примеры вложенных и анонимных функций, карринга. Всё это Scala умеет, но всё нельзя включить в небольшой обзор. Думаю приведёный пример достаточен для понимания важности и, главное, — удобства функций высокого порядка как инструмента программирования. Напоследок могу посоветовать почитать эту главу замечательной книги по программированию.
Особенности классов
override def toString = real+ » + i*» +image+ » | » +magnitude+ «*e^(i*» +angle+ «))»
>
object Main <
def main(args:Array[ String ]) :Unit = <
val first = new Complex(1, 5)
val second = new Complex(2, 4)
val sum = first + second
println(first)
println(second)
println(sum)
>
>
object Main <
def main(args:Array[ String ]) :Unit = <
val first = new Complex(1, 5)
val second = new Complex(2, 4)
if (first > second )
println( «First greater» )
if (first «Second greater» )
if (first == second )
println( «They’re equal» )
>
>
val user = new User( «Scala. » )
println(user.name)
user.name = «M. Odersky»
println(user.name)
Pattern-matching
case class KnownUser(val name: String ) extends User
case class AnonymousUser() extends User
object Test <
val users = List (KnownUser( «Mark» ), AnonymousUser(), KnownUser( «Phil» ))
def register(user: User): Unit = user match <
case KnownUser(name) => println( «User » + name + » registered» )
case AnonymousUser() => println( «Anonymous user can’t be registered» )
>
def main(args: Array[ String ]) =
users. foreach ( register )
>
Итак, общая картина кода: есть абстрактный класс пользователя, есть два его казуальных потомка: известный и анонимный пользователи. Мы хотим зарегистрировать некий список пользователей на (здесь включаем фантазию) встречу. Для чего и используем pattern-matching, который позволяет нам определить разное поведение метода для разных типов объектов и обеспечивает выборку данных из этих объектов.
Люди знакомые с базовыми принципами ООП конечно сразу заметят, что проблема эта вполне решается использованием виртуальных функций (более того предлагаемый подход является не лучшей практикой). Однако их использование несёт в себе две трудности: во-первых усложняет поддержку кода при большом числе таких функций (нам ведь захочется регистрировать пользователей и на события, и в группы, и в блоги и т.п., что для каждого случая создавать виртуальный метод?), во-вторых не решает проблемы с тем, что объекты одного типа могут принципиально иметь разную структуру и не иметь возможности предоставлять некоторые данные.
Вывод типов
Заключение
Мда… К началу поста уже и скролить долго. Явно пора заканчивать. А сказать хотелось бы ещё про многое: про интереснейший механизм описания обобщённых классов, про неявные преобразования и то, что они на самом деле явные, ленивую инициализацию констант.
Мне и самому ещё только предстоит изучить модель многопоточности и своеобразный набор примитивов для её реаизации, разобраться с языковой поддержкой xml, поиграться с DSL-строением, посмотреть на их флагманский проект — Lift…
UPD: поправил грамматику, спасибо всем оказавшим в этом помощь. Особенно ganqqwerty за массовые разборки с запятыми.
Scala как первый язык
Эта статья, как и мой предыдущий пост, не похожа на то, что обычно публикуют на Хабре. Здесь не объясняется никаких новых или старых концепций, я не рассказываю что такое ООП и функциональное программирование, сложного кода почти нет. Я хочу пригласить вас к дискуссии стоит ли начинать программировать с языка Scala.
Меня иногда просят научить программированию или помочь с поиском подходящего курса. Я хорошо понимаю недостатки и сложности со скалой, но думаю, что Scala 3 — подходящий язык, для того чтобы начать обучение с него, если правильно составить курс. Вся языковая мощь и сложность, конечно, не нужны начинающему программисту, но ему и незачем о них знать. На скале можно писать вполне простой и понятный код, постепенно наращивая инструментарий.
Я согласен с теми комментаторами, кто считает что для этого нужен толковый преподаватель. Это безусловно. Или талантливый преподаватель, который разбирается в предмете, или хорошая книжка, или толковый курс просто необходимы. Иначе есть риск захлебнуться, так и не научившись плавать.
И тем не менее я считаю, что Scala — это язык будущего.
Лестница в логотипе отсылает к институту EPFL в Лозанне. Там придумали этот язык
Если коротко, то Scala — это возможность научиться функциональному программированию на безопасном языке, у которого есть большое будущее
Умный компилятор
У скалы один из самых умных и сложных компиляторов. Это приводит к медленным билдам (особенно в первых версиях языка), и за это скалу хейтят. Но зато мы можем отдать компилятору очень много работы по анализу кода, проверке его на безопасность и отсутствие ошибок, что очень важно для программиста. Эта сложность — на стороне разработчика, в том числе и начинающего, которому компилятор очень помогает и облегчает работу.
Скала — это единственный язык, где я пишу код, и он сразу работает без утомительной отладки. Конечно, так происходит не всегда, но с джавой, джаваскриптом, си, паскалем и бейсиком так не происходило никогда. Я люблю говорить, что джава — это язык для компилятора, а скала — это язык для программиста.
JVM-экосистема
Как известно, Джеймс Гослинг, создатель языка джава, считает самой лучшей ее частью джава-машину. Действительно, много инженеров потратило десятки человеко-лет на разработку виртуальной машины и достигли скоростей, в некоторых случаях превышающих Си++. Вот исследование производительности JVM в мобильных устройствах, в нем чаще побеждает нативный код на Си, но в одном случае победила JVM: Java vs C app performance.
На Android 6 AArch64 JVM победила Си в математических вычислениях, хотя и проиграла во всех других видах
Java Memory Model (Модель памяти для многопоточных вычислений) — это зрелая, непротиворечивая, проверенная многими годами промышленного программирования парадигма, которая при правильном использовании гарантирует достаточный уровень абстракции и безопасности. Благодаря этому возможны удобные конструкции для параллельного программирования, доступные даже начинающим.
Кроме того, на джаве написаны миллионы строк кода, которые вы можете использовать из скалы или без проблем в нее транслировать.
Кстати, Джеймсу Гослингу скала тоже нравится.
Но в этом всем есть и минусы. Как мы знаем, высокоуровневые абстракции протекают, и для того чтобы программировать на скале, важно знать как устроена виртуальная машина джава, и учитывать ее особенности. Например, такие как Type Erasure. Это довольно серьезный минус, но плюсы от использования JVM его перевешивают.
Эволюция 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
Dependent Object Types — это теоретические основы языка Scala 3, разработанные его основателем Мартином Одерски. Мало какой язык может похвастать математически точным исчислением, лежащем в его основе.
Мартин Одерски
Согласитесь, приятно учить язык с таким бэкграундом, хотя начинающим программистам знать о нём не обязательно.
Выразительность и лаконичность
То, что я больше всего люблю в языке — это его сжатость и лаконичность. Я ненавижу длиннейшие конструкции джавы, в которых приходится сложно и многословно объяснять компилятору простые вещи. Моя любимая шутка про джаву — что это такой язык, в котором уан-лайнер занимает около 30 строк. Так вот, в скале уан-лайнер — это уан-лайнер.
Я думаю, что это качество важно не только для опытных разработчиков, но и для тех кто только изучает язык. Думаю, выразительность — это та причина, по которой так популярны динамические и скриптовые языки. Уверен, скала способна с ними в этом поспорить. И даже сама послужить отличным скриптовым языком.
Конечно, лаконичность не должна наносить ущерб читаемости кода. Таких неудачных примеров в программировании полно, вспомним регулярные выражения, паттерн-матчинг и парсер-комбинаторы. Понятно, что для написания библиотек важно понимать сложные концепции и знать много умных слов. Но для того, чтобы ими пользоваться и писать простой код, всего этого знать не надо. Минимальный уровень скалы, который подойдет начинающим, очень простой.
Вот мой любимый пример для библиотечного кода на скале. Конечно, он не предназначен для начинающих разработчиков:
В новой версии языка даже есть возможность писать намного меньше фигурных скобок, если есть желание. Это будет выглядеть примерно так:
Статическая типизация
По-моему это самое важное, что должно быть в первом языке программирования. Программисту важно понимать, что не стоит складывать яблоки с апельсинами.
Именно по этой причине на мой взгляд не стоит начинать обучение с Питона, Руби, Джаваскрипта, Си и Си++. Динамическая типизация — это верный способ выстрелить себе в ногу.
Другое дело, что статическая типизация неудобна, неочевидна и требует дополнительного бойлер-плейта. Скала вполне успешно позволяет избавиться от этих недостатков в простых программах.
Объектно-ориентированное программирование — это самая популярная парадигма, без которой не обходится ни один современный язык программирования.
В скале эта парадигма изначально присуща языку, в отличии от Питона, Си/Си++ и в каком-то смысле джаваскрипта. Разумеется, сейчас у этих языков с ООП полный порядок.
Функциональное программирование
Функциональное программирование — это многообещающая тенденция. Скале она присуща в не меньшей степени чем ООП, и они взаимно обогащают друг друга благодаря этому языку. Рискну предположить, что скала — первый язык промышленного уровня с такими свойствами. Сейчас за ним подтягивается Котлин и другие более новые языки.
Начинающим разработчикам стоит узнать про функциональное программирование подробнее, этот подход позволяет писать гибкий, надежный и хорошо масштабируемый код. Вот несколько хабропостов о нём:
Иммутабельность
Вообще-то это свойство функционального программирования. Мне кажется очень важным прививать умение пользоваться неизменяемыми структурами данных с самого начала. Это позволит в будущем создавать безопасный многопоточный код. И не только многопоточный.
Расширяемость
Как известно, название языка изначально преподносилось как аббревиатура Scalable Language. Особенности языка позволяют писать гибкие и красивые DSL, удобные даже для не-программистов, вкладывать абстракции друг в друга, создавать очень удобные библиотеки и простые скрипты.
Часто этот инструмент обращается против пользователей библиотек, повышая порог входа в их API. Но в умелых руках такая гибкость может обратиться в большое благо. Опытные разработчики могу создавать на Scala простое и удобное API, тем самым заметно облегчая жизнь начинающим программистам.
В целом язык скала предоставляет большое количество мощных инструментов, и обратная сторона этого — высокий порог входа, особенно в отсутствии хорошего курса, учебника, или наставника.
Но думаю, что с хорошим наставником или туториалом вполне можно начинать изучать программирование с языка скала и получать правильные привычки статической типизации, функционального программирования и иммутабельных структур данных.
Источник: https://prwatech.in/blog/apache-spark/introduction-to-scala-programming-language/
Рынок вакансий
Конечно, вакансий для скала-программистов значительно меньше, чем для джава-программистов. Но зато Scala выше оплачивается.
https://insights.stackoverflow.com/survey/2019
Вот вам картинка про области применения скалы:
Источник: https://prwatech.in/blog/apache-spark/introduction-to-scala-programming-language/
Мои первые книжки
Самая лучшая книжка про скалу, которую я читал — 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
Java 8
Java 7
Поступь прогресса
На прощанье — шутка Кея Хорстмана «The March of Progress»
1980: C
1988: C++
1996: Java
2004: Java
2008: Scala and Groovy
2012: Scala 2.10
На этом я рискну опубликовать этот пост, но по-прежнему планирую его дописывать по результатам обсуждения с вами.