Обновить
11.83

Scala *

Мультипарадигмальный язык программирования

Сначала показывать
Порог рейтинга
Уровень сложности

Изучаю Scala: Часть 3 — Юнит Тесты

Время на прочтение4 мин
Количество просмотров4K


Привет, Хабр! Мало написать хороший код. Нужно еще покрыть его хорошими Юнит Тестами. В прошлой статье я сделал простой веб сервер. Теперь попробую написать насколько тестов. Обычных, Property-based и с моками. За подробностями добро пожаловать под кат.
Читать дальше →

Fetch — библиотека для доступа к данным

Время на прочтение22 мин
Количество просмотров2.7K

Fetch — это библиотека Scala для организации доступа к данным из файловых систем, БД, веб-сервисов и любых других источников, данные из которых можно получить по уникальному идентификатору. Библиотека написана в функциональном стиле и основана на Cats и Cats Effect. Предназначена для композиции и оптимизации выполнения запросов к разным источникам данных. Она позволяет:


  • запрашивать данные из нескольких источников параллельно;
  • запрашивать данные из одного источника параллельно;
  • объединять запросы к одному источнику в один запрос;
  • производить дедупликацию запросов в каждой из перечисленных ситуаций;
  • кэшировать результаты запросов.

Для этого в библиотеке предоставляются средства, которые позволяют писать чистый бизнес-код без низкоуровневых конструкций для осуществления перечисленных оптимизаций.
В примерах используется последняя на момент написания версия Fetch — 1.3.0.

Читать дальше →

Определение серверной логики для конечной точки: три подхода

Время на прочтение9 мин
Количество просмотров4.3K

Перевод статьи подготовлен в преддверии старта курса «Scala-разработчик»





Теа, Ральф и Джесси используют tapir для описания своих конечных точек HTTP. Им нравится его удобный для программиста API, способ описания конечных точек, возможность использовать одно и то же описание для генерации сервера, клиента или документации, а также его возможности абстракции.


Однако, когда дело доходит до определения серверной логики для конечных точек (то есть, что должно произойти, когда их конечные точки интерпретируются как сервер и подвергаются воздействию внешнего мира), приоритеты у них разнятся. К нашей великой удаче, все три подхода теперь покрыты tapir!

Читать дальше →

Применение ZIO ZLayer

Время на прочтение9 мин
Количество просмотров4.2K
В июле OTUS запускает новый курс «Scala-разработчик», в связи с чем мы подготовили для вас перевод полезного материала.




Новая функция ZLayer в ZIO 1.0.0-RC18+ является значительным улучшением старого паттерна модулей, что делает добавление новых сервисов намного быстрее и легче. Однако при использовании на практике я обнаружил, что может потребоваться какое-то время, чтобы освоить эту идиому.

Ниже приведен аннотированный пример финальной версии моего тестового кода, в котором я рассматриваю ряд вариантов использования. Большое спасибо Адаму Фрейзеру за помощь в оптимизации и облагораживании моей работы. Сервисы преднамеренно упрощены, так что, надеюсь, они будут достаточно понятны для быстрого чтения.
Читать дальше →

Изучаю Scala: Часть 2 — Todo лист с возможностью загрузки картинок

Время на прочтение4 мин
Количество просмотров4.4K

Привет, Хабр! Следующий этап изучения нового языка это старый добрый todo list c картинками. Чтобы научится работе с базой данных и файловой системой. Работе со стримами. За подробностями добро пожаловать под кат.
Читать дальше →

Аккуратно и системно облегчаем понимание кода

Время на прочтение5 мин
Количество просмотров2.7K

Читаемость кода упрощает как процесс написания программ, так и последующие действия – от отладки и оптимизации до тестирования и сопровождения.


image


Один из эффективных способов для понимания кода – применение функциональной парадигмы программирования. Основная идея функционального программирования состоит в представлении процесса вычислений как последовательного изменения состояний без хранения где-либо самих состояний. В качестве примера системы, в которой хорошо реализован функциональный подход, часто приводят Haskell, а также Erlang или Scala. Внедряя такой подход в распространенные языки, такие как JS или Swift, можно добиться как улучшения читаемости, так и тестируемости.


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

Читать дальше →

Functional FizzBuzz на Scala

Время на прочтение3 мин
Количество просмотров5.6K

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


Предлагаю вашему вниманию еще один вариант, не совсем пятничный, а скорее субботний: FizzBuzz на Scala, functional style.

Читать дальше →

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

Время на прочтение15 мин
Количество просмотров93K

Я несколько раз начинал читать статьи из серии «Введение в функциональное программирование», «Введение в Теорию Категорий» и даже «Введение в Лямбда Исчисление». Причем и на русском, и на английском. Каждый раз впечатление было очень сходным: во-первых, много новых непонятных слов; во-вторых, много новых определений, которые возникают из ниоткуда; в-третьих, совершенно непонятно, как это использовать.


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


Попытки использовать как-то в работе изученные концепции разбивались о полное непонимание, как применить полученное глубокое знание. Ведь, напомню, что парадигму ФП (где-то удобнее, где-то не очень, но) можно использовать практически в любом ЯП, совсем необязательно для этого изучать условный Хаскель.

Читать дальше →

Игра с открытым API: Swagger Play

Время на прочтение7 мин
Количество просмотров12K

В данной статье я хочу рассказать, как использовать Swagger модуль для Play Framework, с примерами из реальной жизни. Я расскажу:

  1. Как прикрутить последнюю версию Swagger-Play (модуль Play, позволяющий использовать аннотации swagger-api и генерировать на их основе документацию в соответствии со спецификацией OpenAPI) и как настроить swagger-ui (библиотеку javascript, служащую для визуализации сгенерированной документации)
  2. Опишу основные аннотации Swagger-Core и расскажу об особенностях их использования для Scala
  3. Расскажу, как правильно работать с классами моделей данных
  4. Как обойти проблему обобщенных типов в Swagger, который не умеет работать с дженериками
  5. Как научить Swagger понимать ADT (алгебраические типы данных)
  6. Как описывать коллекции

Статья будет интересна всем, кто использует Play Framework на Scala и собирается автоматизировать документирование API.
Читать дальше →

Изучаю Scala: Часть 1 — Игра змейка

Время на прочтение4 мин
Количество просмотров6.1K

Привет Хабр! Когда я изучаю новый язык я обычно делаю на нем змейку. Может какому-нибудь новичку который тоже изучает Scala будет интересен код другого новичка в этом ЯП. У опытных скалистов скорее всего мой первый код на Scala вызовет грусть. За подробностями добро пожаловать под кат.
Читать дальше →

Исследование Курса по Реактивной Архитектуре: Открытия и Впечатления

Время на прочтение2 мин
Количество просмотров1.7K

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



Курс состоит из шести модулей, каждый из которых завершается финальным экзаменом и практическими заданиями, предоставляя всестороннее изучение реактивной архитектуры. Весь материал иллюстрируется на примере бизнеса сети ресторанов "Реактивное BBQ". В начале эта сеть использовала монолитную модель, но со временем она трансформировалась в сложную систему, которая требует более продвинутого ПО для поддержки своего растущего бизнеса.


Особо интересны два кейса из курса:


  • В первом случае рассматривается управление персоналом в ресторане, что демонстрирует принцип эластичности — один из ключевых аспектов реактивных систем.
Читать дальше →

Rust. Borrow checker через итераторы

Время на прочтение8 мин
Количество просмотров11K
Привет, Хабр!

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

Последнее время scala является моим основным языком, так что сравнения будут с ней, но их не много и все интуитивно понятные, без магии :)

Статья рассчитана на тех кто что-то слышал о rust'e, но в детали не вдавался.


фотографии взяты отсюда и отсюда
Читать дальше →

Конец хайпа: Что ждёт язык Scala дальше

Время на прочтение13 мин
Количество просмотров25K


Вокруг языка Scala всегда было много хайпа и неоднозначных суждений.


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


В ответ на это один из очень активных членов сообщества (Li Haoyi) описал своё видение дальнейшего пути языка Scala.


Статья у него получилась интересной, посему решил перевести её.

Перевод

Ближайшие события

Сортировка в Scala — пример на кошках

Время на прочтение10 мин
Количество просмотров4K

Привет, Хабр! Выношу на ваш суд русскоязычный перевод моей статьи на Medium: Sorting in Scala — a cat shop example. Статья рассчитана на читателей, знающих синтаксис языка Scala и осведомлённых о базовых инструментах стандартной библиотеки.

Читать дальше →

Функциональный подход к транзакциям на Scala или пишем свою полезную монаду

Время на прочтение8 мин
Количество просмотров4.5K

Если вы работаете с одной базой данных которая поддерживает транзакции вы даже не задумываетесь о консистентности — база все делает за вас. Если же у вас несколько баз, распределенная система или даже к примеру MongoDB до 4 версии — все не так радужно.


Рассмотрим пример — мы хотим сохранить файл в хранилище и добавить ссылку на него в два документа. Конечно же мы хотим атомарности — либо файл сохранен и добавлен в документы либо ни то ни другое (тут и далее используется cats-effects IO):


saveDataToFile(data) // (1)
  .flatMap { file =>
    addFileRef(documentId, file) // (2)
      .flatMap { result =>
        addFileRef(fileRegistry, file) // (3)
          .flatMap { result =>
            ??? // (4, 5, ...)
          }
          .handleErrorWith { error =>
            // revert (2)
            removeFileRef(documentId, file).attempt >> IO.raiseError(error)
          }
      }
      .handleErrorWith { error =>
        // revert (1)
        removeFile(file).attempt >> IO.raiseError(error)
      }
  }

Уже непросто? Легко представить как количество операций растет и образуется Pyramid of doom.


Но мы же программисты! Давайте обобщим проблему и напишем код, который позволит избежать ненужной сложности и возможных ошибок.

Читать дальше →

Null подкрался незаметно: ломаем Scala Option с помощью Java

Время на прочтение5 мин
Количество просмотров3.5K

Приветствую, Хабр! Предлагаю вашему вниманию небольшую пятничную статью про Java, Scala, ненормальных программистов и нарушенные обещания.




Простые наблюдения иногда приводят к не очень простым вопросам.


Вот, к примеру, простой и внешне, пожалуй, даже тривиальный факт, гласящий, что в Java можно расширять любой не-final класс и любой интерфейс в области видимости. И другой, тоже достаточно простой, гласящий, что Scala-код, скомпилированный для JVM, может использоваться из Java-кода.


Сочетание этих двух фактов, однако, заставило меня задаться вопросом: а как поведёт себя с точки зрения Java какой-нибудь класс, который в Scala является sealed, т.е. не может быть расширен внешним относительно его собственного файла кодом?



Декомпилированный Scala-класс в представлении художника. Источник: https://specmahina.ru/wp-content/uploads/2018/08/razobrannaya-benzopila.jpg


В качестве подопытного кролика я взял стандартный класс Option. Скормив его декомпилятору, встроенному в IntelliJ Idea, получаем примерно следующее:


// опустим импорты, они сейчас не слишком интересны
public abstract class Option 
implements IterableOnce, Product, Serializable {
    // кучка реализаций методов
    public abstract Object get();
    // ещё кучка реализаций методов
}
- Ага! - сказали суровые сибирские мужики...

Приглашаем на SPb Scala Meetup 2020.1

Время на прочтение2 мин
Количество просмотров1.2K
Встречаемся 19 февраля, чтобы обсудить наболевшее – Scala системы сборки. Встреча сообщества состоится в нашем офисе (Старо-Петергофский, 19).

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

Под катом — подробнее о докладах, ссылка на регистрацию для участия во встрече и информация о трансляции.

image
Читать дальше →

Идеальный SAST. Парсер

Время на прочтение5 мин
Количество просмотров2.6K
Цикл статей посвящен описанию оптимального подхода для реализаций инструментов статического анализа кода, рассчитан на специалистов. Целью работы являются подходы, модели и методики для получения максимальной производительности инструмента при минимизации трудоемкости разработки и поддержки/изменения инструмента. В данной статье рассматривается способ ускорения работы парсера и снижения потребления памяти. Статья построена таким образом, что читатель прочел руководство написанное Терренсом Парром.
Читать дальше →

Ищем цепочку событий в потоке данных с помощью FlinkCEP

Время на прочтение16 мин
Количество просмотров3.8K
В данной статье речь пойдет об использовании открытой платформы Apache Flink для обнаружения цепочки последовательности событий. Статья подойдет как для начинающих разработчиков в области обработки потоковых данных, так и для тех, кто желает познакомиться с Apache Flink.

Ни для кого не секрет, что на данный момент существуют различные подходы к обработке, хранению, фильтрации и анализу больших данных. В отдельный класс можно выделить системы, построенные на событийной архитектуре (Event-Driven Architecture). Данные системы призваны решать различные задачи, в том числе в режимах близких к реальному времени. Одной из таких задач является обнаружение (детектирование, идентификация) сложных цепочек связанных событий на больших входных потоках данных (FlinkCEP — Pattern Detection). Обычно, данная задача, решается системами комплексной обработки событий (CEP), которые должны обрабатывать сотни, а порой и тысячи определенных пользователем шаблонов на входном потоке данных в поисках определенного события, аномалий, системах мошенничества и даже предсказании будущего на основе текущих событий. В статье речь пойдет о библиотеке FlinkCep Apache Flink, которая позволяет решать подобные проблемы.
Читать дальше →

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

Время на прочтение5 мин
Количество просмотров15K
Привет, Хабр!

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

  1. Для императивной реализации — выигрыш от Rust получился всего 20 %. Это означает, что JVM вплотную приблизилась к нативной производительности, и тут уже нечего улучшать.
  2. Для функциональной реализации — Rust оказался быстрее в 4.5 раза, потребление памяти снизилось в 5.5 раза, а отсутствие сборщика мусора сделало программу более стабильной (меньше разброс показателей). Это интересно для тех, кто хочет писать быстрые функциональные программы.
  3. Концепция единственного владельца данных (и единственной мутабельной ссылки), принятая в Rust, очень близка концепции иммутабельности, в результате чего функциональные алгоритмы, основанные на неизменяемости, рекурсии и копировании, легко ложатся на Rust практически без переписывания, тогда как императивные алгоритмы заставляют редизайнить код, учитывать мутабельность ссылок, времена жизни, и т.д.

Вывод — Rust как будто специально создан для ФП, хотя возможности его синтаксиса пока не дотягивают до Scala.
Читать дальше →