• Медвежьи услуги по требованию

      Можно не читать весь текст — в конце есть краткое содержание. Это я о вас забочусь, потому что я — хороший.

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

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

      Как-то давно я работал ИТ-директором, и меня заставили написать то ли положение об отделе, то ли стратегию – не помню, как называлась эта бумажка. Проверяли ее лютые бюрократы, но одну фразу они пропустили, и в ней содержалась квинтэссенция этой штуки.

      Звучало примерно так. Если Заказчик услуг ИТ-отдела хочет совершить ошибку, то ИТ-отдел ему об этом скажет. Если Заказчик настаивает на совершении ошибки, то ИТ-отдел с радостью ему в этом поможет.
      Читать дальше →
    • Rust: состояния типов

      • Перевод
      • Tutorial

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


      Прошу под кат.

      Читать дальше →
    • У семи программистов адрес без дома

        Привет, Хабр!

        Мы в HumanFactorLabs парсим адреса в особо крупных размерах. Наши продукты упрощают ввод контактных данных и работу с ними.

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

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

        Меня давно занимал вопрос: «а что, если попробовать прогнать цифровую запись песни через преобразование Фурье, посмотреть зависимость спектра от времени и попытаться вытащить из полученной информации аккорды песни?». Вот, наконец, нашел время попробовать…
        Читать дальше →
      • Возвращаясь к Неразмеченным Конечным Интерпретаторам с Dotty

        Неразмеченные Конечные Интепретаторы (Tagless Final interpreters — прим. пер.) — это альтернативный подход традиционным Алгебраическим Типам Данных (и обобщённым ADT), основанный на реализации паттерна "интерпретатор". Этот текст представляет "неразмеченный конечный" подход в Scala, и демонстрирует каким образом Dotty с его недавно добавленными типами неявных функций делает этот подход ещё более привлекательным. Все примеры кода — это прямое переложение их Haskell версий, представленных в Typed Tagless Final Interpreters: Lecture Notes (раздел 2).


        Паттерн "интерпретатор" в последнее время привлекает всё больше внимания в сообществе Scala. Множество усилий было затрачено на борьбу с наиболее ярким недостатком решений, основанных на ADT/GADT: расширяемость. Для начала можно взглянуть на typeclass Inject из cats как на реализацию идей Data Type à la Carte. Библиотека Freek предоставляет средства для комбинирования более двух алгебр, используя украшения с задействованием аппарата операций на уровне типов. Решение, предложенное в работе Freer Monads, More Extensible Effects также ставит акцент на расширяемости, и вдохновлено набором небольших Scala-библиотек, таких как eff, emm и paperdoll. Неразмеченные конечные интерпретаторы подходят в некотором смысле с противоположной стороны, используя типы классов в своём непосредственном основании вместо более традиционных ADT/GADT. Они также поставляются с большим превосходством в расширяемости "из коробки" без каких-то явных опасностей.


        Читать дальше →
      • От зависимых типов к гомотопической теории типов на Scala + Shapeless + ProvingGround

        Всем привет. Хочу поделиться своим опытом использования библиотеки ProvingGround, написанной на Скале с использованием Shapeless. У библиотеки имеется документация, правда, не очень обширная. Автор библиотеки — Сиддхартха Гаджил из Indian Institute of Science. Библиотека экспериментальная. Сам Сиддхартха говорит, что это пока не библиотека, а «work in progress». Глобальная цель библиотеки — брать статью живого математика, парсить текст, переводить естественный язык с формулами в формальные доказательства, которые мог бы чекать компилятор. Понятно, что до этого еще очень далеко. Пока что в библиотеке можно работать с зависимыми типами и основами гомотопической теории типов (HoTT), (полу-) автоматически доказывать теоремы.
        Читать дальше →
      • Вероятностное программирование на Scala

        • Перевод
        Здравствуйте, дорогие читатели. Сегодня мы публикуем внеочередной перевод — это будет обзорная статья блистательного Ноэля Уэлша о принципах вероятностного программирования. Статья публикуется по заявкам читателей, которые задают нашему блогу все более высокую планку — и это, безусловно, здорово!
        Читать дальше →
        • +15
        • 9,6k
        • 4
      • Свершилось! Процедурные макросы в Rust 1.15

          Ребята, свершилось! После долгих шести недель ожидания наконец вышла версия Rust 1.15 с блекджеком и процедурными макросами.


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


          А что же это дает простым смертным? Практически бесплатную [де]сериализацию, удобный интерфейс к БД, интуитивный веб фреймворк, выводимые конструкторы и много чего еще.


          Да, если вы все еще не добрались до этого языка, то сейчас самое время попробовать, тем более, что теперь установить компилятор и окружение можно одной командой:


          curl https://sh.rustup.rs -sSf | sh

          Впрочем, обо всем по порядку.

          Читать дальше →
        • Жаргон функционального программирования

          • Перевод


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


          В примерах используется JavaScript ES2015). (Почему JavaScript?)


          Работа над материалом продолжается; присылайте свои пулл-реквесты в оригинальный репозиторий на английском языке.


          В документе используются термины из спецификации Fantasy Land spec по мере необходимости.


          Arity (арность)


          Количество аргументов функции. От слов унарный, бинарный, тернарный (unary, binary, ternary) и так далее. Это необычное слово, потому что состоит из двух суффиксов: "-ary" и "-ity.". Сложение, к примеру, принимает два аргумента, поэтому это бинарная функция, или функция, у которой арность равна двум. Иногда используют термин "диадный" (dyadic), если предпочитают греческие корни вместо латинских. Функция, которая принимает произвольное количество аргументов называется, соответственно, вариативной (variadic). Но бинарная функция может принимать два и только два аргумента, без учета каррирования или частичного применения.

          Читать дальше →
        • Рефакторинг при помощи композиции Клейсли

          • Tutorial
          В течение довольно длительного времени мы поддерживали приложение, которое обрабатывает данные в форматах XML и JSON. Обычно поддержка заключается в исправлении дефектов и незначительном расширении функциональности, но иногда она также требует рефакторинга старого кода.


          Рассмотрим, например, функцию getByPath, которая извлекает элемент из XML дерева по его полному пути.

          import scala.xml.{Node => XmlNode}
          
          def getByPath(path: List[String], root: XmlNode): Option[XmlNode] =
            path match {
              case name::names =>
                for {
                  node1 <- root.child.find(_.label == name)
                  node2 <- getByPath(names, node1)
                } yield node2
              case _ => Some(root)
            }


          Эта функция отлично работала, но требования поменялись и теперь нам нужно:

          • Извлекать данные из JSON и, возможно, других древоподобных структур, а не только из XML;
          • Возвращать сообщение об ошибке, если данные не найдены.

          В этой статье мы расскажем, как осуществить рефакторинг функции getByPath, чтобы она соответствовала новым требованиям.
          Читать дальше →
        • Разбавляем асинхронное программирование функциональным на Scala

          Приветствую! В этой статье будет показано, как, имея на руках обычные Future-ы, сделать в scala подобие корутин и асинхронные stream-ы. Этакий небольшой туториал по функциональному программированию.

          Что это и зачем


          Что такое Future человеческим языком
          Future — это сущность, описывающая результат некоторых вычислений, который мы получим не сразу, но в будущем. Но есть одна особенность: зачастую мы, не зная еще результата, точно знаем, что мы с ним будем делать. Например, мы попросили у сервера какой-то конфиг, и теперь у нас есть Future[Config]. Сам конфиг мы еще не получили, но точно знаем, что, когда получим, то достанем из него адрес и по этому адресу попросим у сервера картинку (config => Future[Image]). И Future[Config] способна изменяться таким образом, чтобы мы вместо конфига и потом картинки могли получить сразу картинку. Сущности, способные комбинироваться таким способом, называются монадами.

          К сожалению, простое последовательное комбинирование 2х и более асинхронных операций (загрузить конфиг, а потом картинку по адресу из конфига как пример) — это все, на что способны обычные Future-ы в качестве монад. Они не позволяют ни сохранять состояние, ни делать циклы из асинхронных операций, ни выдавать несколько (или бесконечно много) значений. Вот этими недостатками мы сейчас и займемся.

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

          Применив знания из этой статьи, мы сможем этот процесс описать примерно так:

          Код
          // Про 'FState' - далее, пока же просто примем, что это - такая необычная Future
          def getNextConfig: FState[Config]
          def getTemperature(from: String): FState[Int]
          
          case class State(temperature: Int, sumTemp: Long, count: Int) {
            def isGood = ...
          }
          
          // Как видим, получается единый асинхронный алгоритм с состоянием, 
          // которое извне этого алгоритма не видно
          val handle = 
            while_ ( _.isGood)
            {  for (
                  config <- getNextConfig();
                  if (config.isDefined);  // пустой конфиг - прекращаем выполнение
                  nextValue <- getTemperature(config().source);  // грузим значение температуры
                  state <- gets[State];  // тут мы берем текущее состояние
                  newState = State(nextValue, state.sumTemp + nextValue, state.count + 1);
                  _ <- puts(newState);  // .. и меняем его
                  _ <- runInUiThread { drawOnScreen(newState) }
            ) yield() }
          


          Или вот так:

          Код
          val configs: AsyncStream[Config] = ... // получаем откуда-то stream конфигов
          
          def getTemperature(from: String): FState[Int]
          
          case class State(temperature: Int, sumTemp: Long, count: Int)
          
          // Получается то же самое, только вместо зависимости 'getNextConfig'
          // мы, по сути, передаем сами данные - stream из конфигов
          val handle = 
            foreach(configs) {
              config => for (
                  nextValue <- getTemperature(config().source);  // грузим значение температуры
                  state <- gets[State];  // тут мы берем текущее состояние
                  newState = State(nextValue, state.sumTemp + nextValue, state.count + 1);
                  _ <- puts(newState);  // .. и меняем его
                  _ <- runInUiThread { drawOnScreen(newState) }
              ) yield()  
            }
          


          Всех, кто заинтересовался, прошу под кат.
          Читать дальше →
        • Учим старую собаку новым трюкам или как я научился любить str.format и отказался от %

          • Перевод
          Предлагаю вниманию читателей хабры и поклонникам python перевод довольно объемной статьи о форматировании строк. Сказка будет правдивой и намек в ней будет на то, что консерваторам стоит иногда рассматривать что-то новое, даже если привычка упорно сопротивляется.

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

          Жду замечания по ошибкам в оформлении и опечаткам в личку — с меня традиционные хабраплюшки.
          Далее слова автора оригинальной статьи
        • Функторы, аппликативные функторы и монады в картинках

          • Перевод
          Вот некое простое значение:


          И мы знаем, как к нему можно применить функцию:


          Элементарно. Так что теперь усложним задание — пусть наше значение имеет контекст. Пока что вы можете думать о контексте просто как о ящике, куда можно положить значение:


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


          data Maybe a = Nothing | Just a
          

          Позже мы увидим разницу в поведении функции для Just a против Nothing. Но сначала поговорим о функторах!
          Читать дальше →
        • Нейронная сеть с SoftMax слоем на c#

            Привет, в прошлой статье я рассказал про алгоритм обратного распространения ошибки и привел реализацию, не зависящую от функции ошибки и от функции активации нейрона. Было показано несколько простых примеров подмены этих самых параметров: минимизация квадрата Евклидова расстояния и логарифмического правдоподобия для сигмоидной функции и гиперболического тангенса. Данный пост будет логическим продолжение прошлого, в котором я рассмотрю немного нестандартный пример, а именно функцию активации Softmax для минимизации перекрестной энтропии. Эта модель актуальна при задаче классификации, когда необходимо получить на выходе нейросети вероятности принадлежности входного образа одному из не пересекающихся классов. Очевидно, что суммарный выход сети по всем нейронам выходного слоя должен равняться единице (так же как и для выходных образов обучающей выборки). Однако не достаточно просто нормализировать выходы, а нужно заставить сеть моделировать вероятностное распределение, и обучать ее именно этому. Кстати, сейчас на coursera.org идёт курс по нейросетям, именно он помог углубиться в понимание софтмакса, иначе я продолжал бы использовать сторонние реализации.

            Читать дальше →
            • +13
            • 47,9k
            • 1
          • Что нам стоит сеть построить

            • Tutorial
            Когда пользуешься сложными алгоритмами для решения задач компьютерного зрения — нужно знать основы. Незнание основ приводит к глупейшим ошибкам, к тому, что система выдаёт неверифицируемый результат. Используешь OpenCV, а потом гадаешь: «может, если сделать всё специально под мою задачу ручками было бы сильно лучше?». Зачастую заказчик ставит условие «сторонних библиотек использовать нельзя», или, когда работа идёт для какого-нибудь микроконтроллера, — всё нужно прогать с нуля. Вот тут и приходит облом: в обозримые сроки реально что-то сделать, только зная как работают основы. При этом чтения статей зачастую не хватает. Прочитать статью про распознавание номеров и попробовать самому такое сделать — огромная пропасть. Поэтому лично я стараюсь периодически писать какие-нибудь простенькие программки, включающие в себя максимум новых и неизвестных для меня алгоритмов + тренирующих старые воспоминания. Рассказ — про один из таких примеров, который я написал за пару вечеров. Как мне показалось, вполне симпатичный набор алгоритмов и методов, позволяющий достичь простенького оценочного результата, которого я ни разу не видел.



            Сидя вечером и страдая от того, что нужно сделать что-то полезное, но не хочется, я наткнулся на очередную статью по нейросетям и загорелся. Нужно сделать наконец-таки свою нейросеть. Идея банальная: все любят нейросети, примеров с открытым кодом масса. Мне иногда приходилось пользоваться и LeNet и сетями из OpenCV. Но меня всегда настораживало, что их характеристики и механику я знаю только по бумажкам. А между знанием «нейросети обучаются методом обратного распространения» и пониманием того, как это сделать пролегает огромная пропасть. И тогда я решился. Пришло время, чтобы 1-2 вечера посидеть и сделать всё своими руками, разобраться и понять.
            Читать дальше →
          • String и &str в функциях Rust

            • Перевод
            КДПВ
            Этот пост посвящается всем тем, кого смущает необходимость использовать to_string(), чтобы заставить программы компилироваться. И я надеюсь пролить немного света на вопрос о том, почему в Rust два строковых типа String и &str.
            Читать дальше →
            • +22
            • 10,9k
            • 6
          • Макросы и квазицитаты в Scala 2.11.0

              Не так давно состоялся релиз Scala 2.11.0. Одним из примечательных нововведений этой версии являются квазицитаты — удобный механизм для описания синтаксических деревьев Scala с помощью разбираемых во время компиляции строк; очевидно, что в первую очередь этот механизм предназначен для использования совместно с макросами.

              Удивительно, но на хабре пока тему макросов в Scala рассматривают не слишком-то активно; последний пост
              с серьёзным рассмотрением макросов был аж целый год назад.

              В данном посте будет подробно рассмотрено написание простого макроса, предназначенного для генерации кода десериализации JSON в иерархию классов.
              Читать дальше →
              • +25
              • 10,5k
              • 8
            • Строго типизированное представление неполных данных

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

                В обновлённом варианте библиотеки synapse-frames исключительно просто описываются иерархические структуры данных и представляются любые подмножества таких структур.

                Читать дальше →
                • +17
                • 7,2k
                • 2
              • Rust в деталях: пишем масштабируемый чат с нуля, часть 1

                • Перевод

                Часть 1: Реализуем WebSocket. Введение.


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

                В первой части мы рассмотрим начальную настройку окружения и реализацию простейшего WebSocket-сервера. Чтобы понять технические детали статьи вам не потребуется опыта работы с языком Rust, хотя знание основ системных API (POSIX) и C/C++ лишним не будет. Прежде чем начинать чтение, заготовьте немного времени (и кофе) — статья описывает все максимально подробно и поэтому довольно длинная.

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