Alex Ott's Russian blog about IT-related things

Итоги года...

2011-12-31T16:27:00.000+01:00

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

получил повышение до Principal разработчика, что добавило задач, но проекты были интересными, и будут новые
достаточно много ездил - в другие страны (англия, голландия, канарские острова) и в германии (по рейну, в Кельн на карнавал, и т.д.)
накатал 2000км на велосипеде, хотя это меньше чем я планировал
достаточно много "книжных" проектов - работал с Manning над "Mahout in Action" & "Tika in Action", наконец-то вышел перевод TaPL в его окончательном варианте
в части open source активность была не особо высокой - обычно в виде небольших патчей для разных проектов
для статей тоже не особо много времени находилось - написал только статью про TDD & Unit testing in C++, и вместе с Дмитрием Бушенко, написали небольшое пособие про Emacs, которое мы планируем в следующем году значительно расширить информацией про CEDET/Semantic для Java и т.п.
много читал, в основном техническую литературу
учился в двух стенфордских классах, что доставило очень большое удовольствие и позволило многому научиться

В следующем году продолжу разбираться с темами, которые мне интересны - machine learning, natural language processing (в том числе возьму и стенфордский класс на эту тему), постараюсь больше писать на разные темы, и более активно учавствовать в open source проектах. И проехать 3000км на велосипеде (надо только его проапгрейдить до шоссейника)...

И хочу поздравить всех моих читателей с Новым, 2012-м годом - пусть он будет успешным и интересным для вас!

Про Стэнфордские курсы...

2011-12-23T19:52:00.003+01:00

Я как и многие мои знакомые, учавствовал в экспериментальных учебных курсах предложенных Стэнфордским университетом. В виду ~~патологической жадности~~ любви к учебе, записался сразу на два курса Artificial Intelligence (AI) & Machine Leaning (ML), оба на advanced track, что предполагало делание домашних заданий в дополнение к вопросам в ходе лекций. Вчера я получил свой сертификат для AI - 89%, чему я с одной стороны рад, поскольку я смог это сделать, с другой стороны - корю себя за невнимательность и несобранность - было сделано достаточно много глупых ошибок. Сертификат по ML скорее всего придет на той неделе.
Я собирался написать про свои впечатления об обоих курсах, но Lev Walkin меня опередил отличных постом в своем журнале. Мои впечатления полностью совпадают с тем, что он написал - возможность получения немедленного feedback на ML-курсе, позволила гораздо лучше запомнить материал по сравнению с тем что давали на AI. Но стоит отметить, что AI тоже не прошел даром - обзорные лекции по разным темам дали возможность на них посмотреть чуть ближе, и понять что из них будет интересно и применимо.
Оба курса были также хорошей возможностью чуть лучше сконцентрироваться на определенных темах, поскольку домашние работы надо было выполнять в срок. Плюс это дало возможность наконец-то почитать давно купленные книги, например, Artificial Intelligence: A Modern Approach (у меня 2-е, русское издание), купленное много лет назад, и иногда доставаемое с полки для чтения какой-то главы :-)

А в конце января, начнется новая серия курсов, я скорее всего возьму только один - Natural Language Processing (так что я достану из загашников еще пару книжек :-), хотя хочется взять половину из новых курсов, даже 2 курса одновременно - это достаточно затратно по времени, так что буду надеяться что все курсы будут оставаться в открытом доступе и в дальнейшем (по крайней мере, курс по ML будет повторен и в новом семестре).

Перевод TaPL в продаже

2011-11-27T16:09:00.001+01:00

Для заинтересованных - перевод TaPL можно уже купить. findbook показывает что можно заказать через goodreads.ru, books.ru имеет книгу в каталоге, но она помечена как "нет в продаже"...

Судя по информаци из juick, в Москве можно купить в обычных книжных магазинах: "В москве продаётся как минимум в МДК (на арбате и в техкниге), в Москве (на тверской), и в библиоглобусе. Дешевле всего (за 1100р) можно купить в МЦНМО (mccme.ru). туда лучше заранее позвонить, ибо много книг хранить они не могут"...

P.S. а озон почему-то выставил безумную цену в 2 с лишним тысячи, поэтому они идут лесом :-)

Update: Алексей Махоткин написал пост, где собрал список всех известных магазинов и других способов покупки книги...

Еще книжное...

2011-10-22T14:12:00.000+01:00

Осень выдается достаточно результативной на книги, к которым я имею отношение в той или иной мере... Кроме релиза про перевод Types & programming languages, про который я писал вчера, сегодня я получил свой экземпляр книги Mahout in Action, в издании которой я принимал участие в качестве technical proofreader. В том же качестве я поработал и над книгой Tika in Action, которая должна выйти в ближайшее время. А началось все с того, что люди из Manning предложили мне сделать review для нескольких книг, часть из которых я уже купил как MEAP, а потом предложили сделать и technical proofreading - проверить примеры, формулы и т.п., что и было с удовольствием сделано - все равно я собирался читать эту книгу, а тут такая возможность :-)

Mahout in Action - интересная книга, если вы интересуетесь machine learning, особенно в large scale. В книжке почти нет теории, но в ней подробно описывается как использовать Apache Mahout для классификации и кластеризации данных, а также рекомендаций (для товаров и т.п.). В книге описаны только основные алгоритмы, в самом Mahout их гораздо больше, и все больше добавляется с каждым релизом.
В электронной версии (в PDF) есть мультимедийные вставки, с помощью которых рассказывают или показывают про сложные места - интересно сделано. На амазоне, печатная книга стоит дешевле чем у Manning'а, но у Manning'а вместе с печатной версией дают и электронную - это у них стандартные условия, плюс регулярно бывают 40-50% скидки - если кому интересно. Все примеры были протестированы на Mahout версии 0.5 (актуальный релиз), но я планирую в ближайшее время сделать их совместимыми со следующим релизом - 0.6 - там совсем небольшое изменение...

P.S. будет еще несколько книг, но уже на русском, но я пока не знаю еще точных сроков выхода, но обязательно напишу :-)

Книга "Типы в языках программирования"

2011-10-21T11:59:00.000+01:00

Из достоверных источников стало известно, что книга "Типы в языках программирования" (перевод известной "Types and Programming Languages") вышла в бумажном виде, и это не миф :-) Пока правда неизвестно где ее можно купить, но вы можете связаться с Алексеем Махоткиным (aka squadette) и узнать об этом. Я тоже напишу когда она будет доступна в магазинах.
Также доступна полная электронная версия книги, она совпадает с печатной версией. Меньшего формата не будет (пока?), поскольку там есть проблемы с таблицами и листингами, но вы можете попытаться переверстать, благо исходные тексты также доступны.
Эта книга труд многих людей - Юра Бронников сделал львинную часть перевода, Алексей Махоткин сделал огромную работу по вычитке и редактированию, а Вадим Родионов так красиво и правильно все сверстал. Кроме того, много людей читало промежуточные версии перевода и присылало замечания и пожелания - всем спасибо!

Что нового в Clojure 1.3?

2011-09-24T16:14:00.000+01:00

Сегодня ночью была выпущена новая версия языка Clojure — 1.3. Что нового в этой версии? Давайте рассмотрим основные изменения сделанные в этой версии (детальный список изменений можно найти в соответствующей ветке репозитория).

Расширенная поддержка примитивных типов

В предыдущих версиях, примитивные типы (long, double, etc.) поддерживались только для локальных арифметических операций и при объявлении полей deftype/defrecord, но не для аргументов функций и не для возвращаемых значений. Boxing выполнялся всегда, что часто приводило к ощутимым накладным расходам.

В новой версии примитивные типы поддерживаются в полной мере, что приводит к значительному увеличению производительности кода (в соответствующих тестах, в среднем в 3-5 раз). Соответственно изменилась работа с арифметическими выражениями — для примитивных типов будут использоваться стандартные операторы Java. Но при этом не будет происходит автоматического превращения в "Big*" типы при переполнении, как это происходило раньше — вместо этого будет брошено исключение. Если вам все-таки нужно автоматическая конвертация, то вы можете использовать операторы +', *', и т.д., хотя они и более медленные. Битовые операции теперь только поддерживаются для примитивных типов, и вся их поддержка для "Big*" была убрана из языка.

Для использования примитивных типов вам необходимо добавить соответствующие type hints, например:

(defn fib ^long [^long n]
    (if (<= n 1)
        1
        (+ (fib (dec n)) (fib (- n 2)))))

Более подробно обо всем этом на соответствующей странице JIRA.

Улучшения `defrecord` и `deftype`

В версии 1.3 были сделаны различные улучшения для работы с defrecord и deftype:

новый синтаксис для чтения и записи — либо с метками (#myns.MyRecord{:a 1, :b 2} — только для записей), либо позиционный (#myns.MyRecord[1 2] — для записей и типов);
автоматическая генерация функций для создания типов и записей: myns/map->MyRecord (только для записей) и myns/->MyRecord (для записей и типов).

Подробнее можно прочитать вот тут.

Reflection API

Введено новое пространство имен clojure.reflect, функции которого должны обеспечить более удобную и быструю работу с классами, методами и т.д. Подробнее об этом тут.

Модульный `clojure-contrib`

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

Множественные улучшения производительности

Кроме улучшений в части производительности, описанных выше, в новом релизе сделано множество изменений чтобы обеспечить более высокую скорость работы программ на Clojure:

Более быстрый доступ к переменным;
Ускорение загрузки
Promises не используют блокировок (locks);
Инлайнинг nil?, битовых функций, математических операций, функций min & max с разным числом аргументов;
и многое другое...

Прочее

Помимо новой функциональности описанной выше, а также различных исправлений ошибок, в новой версии реализованы новые вещи (перечислены не все):

Некоторые вспомогательные пространства имен (clojure.set, clojure.xml, clojure.zip) не загружаются при запуске;
Объявления сделанные с помощью def более не являются "динамическими" по умолчанию — вы должны использовать ^:dynamic если хотите иметь возможность использования ее в binding;
Улучшенные сообщения об ошибках и исключениях;
Можно вызвать deref с указанием таймаута;
Функция comp возвращает identity если вызвана без параметров;
Возможность указания разных возвращаемых типов в объявлениях одной функции с разными количествами аргументов;
Некоторые функции перемещены в другие пространства имен;

Перевод " Learn You a Haskell for Great Good!"

2011-09-18T10:59:00.001+01:00

BTW, планируется выпуск русского перевода "Learn You a Haskell for Great Good!" в виде бумажной книги. Переводом занимается Yasir Arsanukaev, и работа над переводом ведется на bitbucket - кто может, присоединяйтесь к вычитке перевода! :-)

P.S. Из достоверных источников стало известно, что книжка уже на этапе верстки, так что недолго ждать осталось :-)

Опрос: название для русской версии Practical Common Lisp

2011-07-01T12:05:00.000+01:00

В процессе причесывания русского перевода Practical Common Lisp, выползла проблема того, как книжка должна называться на русском языке. Пока вариантов немного, и некоторые звучат не особо :-( Поэтому хочу попросить помощи у сообщества - какой из переводов вам больше нравится (или можете предложить свой) - пишите номера или сови предложения в комментариях:

Practical Common Lisp - оставить оригинальное название (будет плохо искаться в поиске, имхо)
(ru '(Practical Common Lisp)) - вариант catap'а
Практика Common Lisp
Common Lisp на практике
Практический Common Lisp
Практический Lisp

Небольшой книжный обзор

2011-05-14T12:26:00.002+01:00

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

Вкратце о разных книгах

За мартовский отпуск дочитал давно лежащую в очереди "The art of meta-object protocol" - книжка дает понимание как проектировался CLOS, как были выбраны те или иные решения, и т.д.
В апреле в достаточно быстром темпе (они предложили сделать ревью) прочитал две книги издательства Manning: Tika in Action и ManifoldCF in Action. Первая была не особо интересной для меня, поскольку я в этой области работаю уже давно, да и tika знаю достаточно хорошо, но я думаю, что книжка все равно будет интересна для людей, которым нужно выделять текст и мета-информацию из файлов разных форматов. А вот вторая книга была более интересной - я ее купил когда она еще только была анонсирована, но руки не доходили ее прочитать. Книга описывает ManifoldCF - расширяемый фреймворк для работы с разными content repositories, откуда можно извлекать информацию для индексирования и прочей обработки. Фреймворк очень интересный, и я надеюсь его запользовать в одном из своих проектов.

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

Также в апреле мне попала на руки книга Дмитрия Сошникова Функциональное программирование на F# (спасибо издательству ДМК-Пресс за предоставленный файл), и я ее неспешно прочитал...
Книга чисто практическая, начинается с примеров, и все остальное вводится по мере повествования. Это же является и ее недостатком - нет подробностей о лямбда-исчислении и синтаксисе языка - для этого требуется обратиться к другим источникам, типа перевода курса лекций Джона Хариссона, и переводу орейлевской книги про F#, которая вышла в издательстве "Символ-Плюс" (я ее правда не читал в переводе).

Описываются все основные приемы программирования - функциональный, императивный и объектно-ориентированный. Достаточно хорошо описаны расширения языка типа активных паттернов, async, etc.

Ну и стоит отдельно упоминуть 7-ю главу, которая содержит примеры решения задач в различных областях - "научное" программирование, графика, программирование для Windows Phone 7, веб-программирование, включая использование F# с ASP.Net, работу с веб-сервисами и т.п.
Я думаю, что книга может быть полезна студентам и начинающим программистам для использования в качестве сборника примеров решения задач. А затем, если язык заинтересует, то можно переходить и к другим книгам...

Новый номер журнала «Практика функционального программирования»

2011-04-13T13:23:00.000+01:00

Вышел свежий (7-й) номер журнала «Практика функционального программирования». В новом номере вы можете прочитать следующие статьи:

Язык РЕФАЛ — взгляд со стороны. Бойко Банчев расскажет о сущности, истории и современном состоянии языка РЕФАЛ.
Circumflex — веб-фреймворк на Scala comme il faut. Александр Темерев даст урок использования этого «обезжиренного» и гибкого веб-фреймворка, написанного на Scala.
Разработка алгоритма обнаружения движения в среде программирования Mathematica. Вадим Залива расскажет об опыте прототипирования такого алгоритма при разработке iPhone-приложения iSentry.
Как написать LDAP-сервер на Erlang и Как написать LDAP-сервер на Си. Максим Сохацкий и Олег Смирнов обменяются любезностями со Львом Валкиным: Максим и Олег похвалят Erlang за то, что на нем можно за 20 минут написать LDAP-сервер, а Лев докажет, что дело тут вовсе не в Erlang.
Продолжения в практике. Алексей Вознюк расскажет об использовании продолжений для упрятывания асинхронности кода за обыкновенным «последовательным» синтаксисом.
Суперкомпиляция: идеи и методы. Илья Ключников, расскажет о суперкомпиляции, построив поразительно компактный и понятный суперкомпилятор простого языка, и покажет, что она применима не только для удивительно мощной оптимизации многих классов программ, но имеет и другие неожиданные применения.

Кроме электронной версии, этот номер доступен и в печатном виде!

Обсудить статьи вы можете в fprog@ЖЖ.

Monad tutorial для кложуры

2011-04-07T09:40:00.000+01:00

Серия слайдкастов про монады на примере Clojure сделанный Brian Marick.
Первая лекция начинается со следующей фразы "Существует предсказание, что когда-то, каждый человек на земле сделает monad tutorial, и высшая цель вселенной будет достигнута, и все человечество попадет в рай..." :-)

Реклама в журнале "Практика функционального программирования"

2011-04-05T08:50:00.001+01:00

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

Дайджест прочитанных книг. Январь 2011

2011-02-09T19:08:00.000+01:00

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

DSLs in Action
Camel in Action
Test-driven development: By Example

DSLs in Action

Давно собирался почитать что-то про domain specific languages (DSL) чтобы найти новые идеи, сравнить с тем что я сам делаю (у меня есть несколько DSL, которые я применяю в рабочих проектах), может быть улучшить свои решения. Мой выбор пал на DSLs in Action, написанную Debasish Ghosh, который является достаточно известным разработчиком в Scala сообществе, хотя использует и другие языки, например, Haskell, Groovy, Clojure. Когда я выбирал что почитать, я также смотрел в сторону книги Domain-Specific Languages, написанную Martin Fowler, но Manning прислал очередную партию скидок, и я купил книгу у них (и не пожалел).

Книга написана очень простым языком, но при этом дается материал очень высокого качества. Автор показывает различные приемы разработки DSL используя разные языки — Ruby, Groovy, Scala, Clojure (в книге используются только языки, работающие только на JVM, и многие вещи применимы только к этой платформе). Это позволяет показать разные подходы к проектированию и реализации DSL (есть также статья в блоге автора о том, почему использовались разные языки).

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

Вторая глава демонстрирует простой DSL, который реализован с помощью стандартной Java, и анализируются недостатки конкретного подхода. Затем, аналогичный DSL создается с помощью Groovy, и рассматриваются его преимущества по сравнению с первой реализаций. В остальной части главы рассматриваются паттерны реализации DSL, с учетом предыдущей информации.

Третья глава посвящена вопросам интеграции DSL в основной проект. В ней обсуждаются java scripting engine, интеграция на базе Spring, и т.д. Для каждого из возможных подходов, рассматриваются преимущества и недостатки данного подхода, то, как он может повлиять на реализацию DSL, и т.д.

Вторая часть (главы 4-8) посвящены реализации DSL на конкретных языках программирования. 4-я глава описывает основные приемы реализации внедряемых (internal) DSL — мета-программирование, типизированные абстракции, генерацию кода во время компиляции и т.д. И следующие две главы (5 и 6), подробно показывают как эти абстракции применяются при реализации DSL на Ruby, Groovy, Clojure и Scala.

Седьмая глава продолжает тему реализации DSL, но уже с точки зрения использования внешних (external) DSL. Рассматриваются разные виды парсеров, с помощью которых можно разбирать код использующий DSL, показывается небольшой пример использования ANTLR для генерации парсеров, и приводится небольшое описание Xtext — фреймворка для Eclipse, который упрощает разработку внешних DSL.

В восьмой главе продолжается тематика использования внешних DSL и в ней показывается применение комбинаторов парсеров для разбора исходного кода DSL. Глава начинается с небольшого описания того, что такое комбинаторы парсеров, а затем показывается пример использования комбинаторов парсеров в Scala для работы с внешними DSL.

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

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

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

Camel in Action

Для очередного из "домашних" проектов понадобилось слепить систему обработки данных из разных источников, поэтому погуглив, я нашел Apache Camel, который показался мне интересным и достаточно зрелым проектом, а на очередной маннинговской распродаже я прикупил книжку Camel in Action авторства Claus Ibsen и Jonathan Anstey.

Книга начинается (глава 1) с объяснения что такое Apache Camel, какие задачи он решает и из чего он состоит. Во второй главе более подробно рассматриваются маршруты (routes) и показывается как можно их создавать используя код на Java или Spring.

Вторая часть книги полностью посвящена базовым вопросам разработки с использованием Camel, показывается как преобразовывать данные, обрабатывать ошибки, тестировать код, и использовать дополнительные компоненты, такие как JMS, базы данных и т.д.

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

Отдельная глава (11-я) описывает организацию процесса разработки с использованием Camel, включая разработку новых компонентов и адаптеров. Кроме этого, на примере DSL для Scala, показывается как использовать Camel с другими языками (хотя на мой взгляд проект scalaz-camel выглядит более интересным).

Заключение: если вы заинтересованы в применении Apache Camel, то книжку стоит прочитать — она может служить как хорошим введением в данную систему, так и достаточно подробным руководством по основным компонентам.

P.S. Для Clojure также начата работа по созданию библиотеки для интеграции с Apache Camel. Проект называется Hackamore и находится в начальной стадии разработки. Если вам это интересно, то вы можете присоединиться к обсуждению в специально созданном списке рассылки.

Test-driven development: By Example

Недавно я готовил презентацию для внутреннего семинара о test driven development (TDD), и решил прочитать что-то от основоположников этого движения. Серию Extreme Programming я читал много лет назад, сразу после ее выхода, поэтому взгляд остановился на книге Test Driven Development: By Example Кента Бека.

Книжка небольшая — чуть больше 200 страниц, но и этот объем является слишком большим для данной темы — автор взял одну проблему, и подробно разбирает процесс ее реализации, который управляется тестами, которые создаются по мере добавления новых требований. На протяжении первой части книги, с помощью данного примера иллюстрируются основы TDD и Unit testing.

Во второй части, применение TDD иллюстрируются описанием процесса реализации xUnit-подобного фреймворка для тестирования кода на Python, начиная с определения основной функциональности фреймворка, и затем, последовательной реализацией кода.

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

Заключение: хорошее введение в TDD, но стоит прочитать только для людей кто никогда с ним не сталкивался — слишком уж начального уровня. Хотя иногда попадаются полезные советы по организации кода, неплохое описание рабочего процесса и т.п. Если вы уже хоть как-то применяли тесты в своей работе, то можно найти более короткий источник нужной информации.

Типы и протоколы в Clojure

2011-02-04T15:19:00.005+01:00

Эта заметка также опубликована как часть статьи "Введение в Clojure"...

Одно из самых больших изменений в Clojure версии 1.2 — введение в язык новых артефактов: протоколов (protocols) и типов данных (datatypes). Данные изменения позволяют улучшить производительность программ по сравнению с мультиметодами, что в будущем даст возможность написать Clojure на Clojure (в данный момент протоколы и типы данных уже активно используются при реализации Clojure).

Что это такое и зачем нужно?

Определение протоколов

Реализация протоколов

Определение типов данных

deftype & defrecord
reify

Дополнительные функции и макросы

Дополнительная информация

Что это такое и зачем нужно?

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

Существует несколько причин введения протоколов и типов данных в новую версию языка:

Увеличить скорость работы полиморфных функций, при этом поддерживая большую часть функциональности мультиметодов, поскольку для протоколов диспатчеризация выполняется только по типу данных;
Использовать лучшие стороны интерфейсов (только спецификация функций, без реализации, реализация нескольких интерфейсов одним типом), в тоже время избегая недостатков (список реализуемых интерфейсов задан во время реализации типа данных, создание иерархии типов вида isa/instanceof);
Избежать Expression problem и дать возможность расширять набор операций над типами данных без изменениях определения типов данных (в том числе и чужих) и перекомпиляции исходного кода¹;
Использовать высокоуровневые абстракции для типов данных и операций над ними², что упрощает проектирование программ.

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

В отличии от имеющегося в Clojure gen-interface (и соответствующих proxy/gen-class) определение протоколов и типов не требует AOT (ahead-of-time) компиляции исходного кода, что упрощает распространение программ на Clojure. Однако при определении протокола, Clojure автоматически создает соответствующий интерфейс, который будет доступен для кода, написанного на Java.

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

Важно помнить, что протоколы и типы данных с одним и тем же именем могут быть определены в разных пространствах имен, так что стоит быть осторожным и не наделать ошибок при импорте определений и последующей реализации протоколов!

Определение протоколов

Протоколом называется именованный набор функций с определенными сигнатурами. Для определения используется макрос, применение которого выглядит следующим образом:

(defprotocol название "описание" & сигнатуры)

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

(имя [аргументы+]+ "описание")

Вы можете определять одну функцию, которая будет принимать различное количество параметров, но первым аргументом функции всегда является объект, на основании которого будет выполняться диспатчеризация, и к которому эта функция будет применяться. Вы можете рассматривать его как this в Java и C++. В дополнение к сигнатурам, вы можете описать вашу функцию, но это необязательно.

Давайте посмотрим на стандартный пример:

(defprotocol AProtocol
  "A doc string for AProtocol abstraction"
  (bar [a b] "bar docs")
  (baz [a] [a b] [a b c] "baz docs"))

Данный протокол определяет две функции: bar — с двумя параметрами, и baz — с одним, двумя или тремя параметрами.

defprotocol также создаст соответствующий интерфейс, с тем же самым именем что и протокол. Данный интерфейс будет иметь те же самые функции, что и протокол.

Реализация протоколов

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

(extend тип-или-класс
  протокол-1
   {:метод-1 уже-определенная-функция
    :метод-2 (fn [a b] ...)
    :метод-3 (fn ([a]...) ([a b] ...)...)}
  протокол-2
    {...}
...)

Для этой функции вы указываете имя типа данных или класса (или nil), и передаете список состоящий из названий протоколов (протокол-1 и т.д.) и отображений, которые связывают функции протокола (метод-1 и т.д.) с их реализациями — анонимными или именованными функциями.

Стоит отметить, что функция extend является низкоуровневым инструментом реализации протоколов. Кроме этого, в состав языка введены макросы extend-protocol & extend-type, которые немного упрощают реализацию протоколов⁴. Протокол также может быть реализован непосредственно при объявлении типа данных.

Использование extend-type выглядит практически также как и использование extend, но пользователь записывает реализации в более удобном виде (extend-type раскрывается в соответствующий вызов extend):

(extend-type тип-или-класс
  протокол-1
    (метод-2 [a b] ...)
    (метод-3 ([a]...)
             ([a b] ...)...)
  протокол-2
    (....)
...)

Макрос extend-protocol использоваться в тех случаях, если вы хотите реализовать один протокол для нескольких типов данных или классов. В общем виде использование extend-protocol выглядит следующим образом:

(extend-protocol название-протокола
  Тип-или-Класс-1
   (метод-1 ...)
   (метод-2 ...)
  Тип-или-Класс-2
   (метод-1 ...)
   (метод-2 ...)
...)

При использовании, extend-protocol раскрывается в серию вызовов extend-type для каждого из используемых типов.

Давайте рассмотрим небольшой пример. Пусть мы объявим следующий простой протокол:

(defprotocol Hello "Test of protocol"
  (hello [this] "hello function"))

Мы можем использовать extend, extend-protocol, или extend-type для его специализации для класса String:

(extend String
  Hello
  {:hello (fn [this] (str "Hello " this "!"))})

(extend-protocol Hello String
  (hello [this] (str "Hello " this "!")))

(extend-type String Hello
  (hello [this] (str "Hello " this "!")))

При использовании любой из этих реализаций для объекта класса String мы получим один и тот же ответ:

user> (hello "world")
"Hello world!"

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

Определение типов данных

В Clojure 1.2 введены два метода определения новых именованных типов данных (deftype и defrecord), которые реализуют абстракции, определенные протоколами и/или интерфейсами (к типам данных относится также reify, который описан ниже).

deftype и defrecord динамически создают именованный класс, который имеет набор заданных полей и (необязательно) методов для одного или нескольких протоколов и/или интерфейсов. Поскольку они не требуют явной компиляции, то это дает возможность их использования в интерактивной разработке. С точки зрения разработчика deftype и defrecord похожи на defstruct, но во многом они отличаются:

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

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

В отличии от deftype, defrecord более прост в использовании, поскольку создаваемый тип данных имеет большую функциональность (по большей части за счет реализации интерфейсов IKeywordLookup, IPersistentMap, Serializable и т.д.):

автоматически генерируемые функции hashCode и equals;
возможность указания мета-информации;
доступ к полям с помощью ключевых символов;
вы можете добавлять поля, не указанные в определении.

deftype и defrecord обычно имеют разные области применения: deftype в основном используется для "системных" вещей — коллекций, и т.п., тогда как defrecord в основном используется для хранения информации из "проблемной области" — данных о заказчиках, записях в БД и т.п. — то, для чего использовались отображения в версиях 1.0 и 1.1.

Давайте рассмотрим как использовать конкретные средства для создания типов данных.

deftype & defrecord

В общей форме использование макросов deftype и defrecord выглядит следующим образом:

(deftype имя [& поля] & спецификации)
(defrecord имя [& поля] & спецификации)

Для обоих макросов обязательным параметром является лишь имя, которое становится именем класса. Поля, которые станут членами класса, перечисляются в векторе, следующем за именем, и могут содержать объявления типов. После этого вектора, можно указать список реализуемых интерфейсов и протоколов, вместе с реализацией (это не обязательно, поскольку для этого вы позже можете использовать extend-protocol & extend-type).

Спецификации протоколов/интерфейсов выглядят следующим образом:

протокол/интерфейс
(название-метода [аргументы*] реализация)*

Вы можете указать любое количество протоколов/интерфейсов, которые будут реализованы данным типом данных. Давайте посмотрим на простейший тип данных, который реализует протокол Hello:

(deftype A []
  Hello
  (hello [this] (str "Hello A!")))

Мы можем вызвать функцию hello для нашего объекта, и получим следующий вывод:

user> (hello (A.))
"Hello A!"

Мы можем также создать тип с помощью defrecord:

(defrecord B [name]
  Hello
  (hello [this] (str "Hello " name "!")))

и вызвать метод hello для этого типа:

user> (hello (B. "world"))
"Hello world!"

Как уже отмечалось выше, создаваемые поля по умолчанию являются неизменяемыми, но если вы создаете тип с помощью deftype, то вы можете пометить некоторые поля как изменяемые, используя метаданные (с помощью ключевого символа :volatile-mutable или :unsynchronized-mutable). Для таких полей вы сможете использовать оператор (set! afield aval) для изменения данных. Давайте посмотрим как это делается на примере — если мы создадим следующий протокол и тип данных:

(defprotocol Setter
  (set-name [this new-name]))
(deftype AM [^{:volatile-mutable true} mfield]
  Hello
  (hello [this] (str "Hello " mfield "!"))
  Setter
  (set-name [this new-name] 
     (set! mfield new-name)))

то мы сможем изменять значение поля:

user> (def am (AM. "world"))
#'user/am
user> (hello am)
"Hello world!"
user> (set-name am "peace")
"peace"
user> (hello am)
"Hello peace!"

reify

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

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

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

Вот небольшой пример реализации протокола Hello для конкретного объекта:

(def int-reify (reify Hello
                 (hello [this] "Hello integer!")))

И при вызове hello для этого объекта, мы получим соответствующий результат:

user> (hello int-reify)
"Hello integer!"

Дополнительные функции и макросы

Для работы с протоколами и типами данных определено некоторое количество вспомогательных функций, которые могут вам понадобиться:

extends?: возвращает true если данный тип данных (2-й аргумент) реализует интерфейс, заданный первым аргументом;
extenders: возвращает коллекцию типов, реализующих заданный протокол;
satisfies?: возвращает true если данный протокол (1-й аргумент) применим к данному объекту (2-й аргумент);

Дополнительная информация

Как всегда, основной источник информации — сайт языка: ознакомьтесь с разделами protocols и datatypes. Хорошее описание протоколов и типов данных можно найти в 13-й главе недавно вышедшей книги Practical Clojure. The Definitive Guide, а также в Clojure in Action и The Joy of Clojure. Thinking the Clojure Way, которые будут выпущены в ближайшее время.

Stuart Halloway создал очень интересный скринкаст в котором он рассказывает о том, зачем были созданы протоколы и data types, и демонстрирует их применение на небольших примерах.

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

Статья Stuart Sierra на IBM developerWorks;
Clojure's Solutions to the Expression Problem — выступление Chris Houser на конференции Strange Loop 2010;
Серия из 3-х статей (1, 2, 3) о протоколах в блоге Object Commando;
Краткое введение в протоколы, написанное Baishampayan Ghose;
Clojure Protocols and Expression Problem;
Два постинга от Sean Devlin — Protocol Implementation Awesomeness и Partially Implemented Protocols;
Пример реализации паттерна "Circuit Breaker" с помощью протоколов;
Пример использования протоколов для мемоизации;
Еще пример использования протоколов для реализации turtle graphics;
Небольшое сравнение Monkey Patching в Ruby с протоколами в Clojure;
Пример реализации стека с помощью протоколов (1, 2), написанный Viksit Gaur;

1. Стоит однако отметить, что протоколы не реализуют monkey patching и внедрение методов
(injection) в существующие типы данных.

2. Возможность реализации абстракций на Clojure и высокая скорость работы протоколов
позволит в будущем написать Clojure на самой Clojure, без использования исходного кода
на Java.

3. Люди знакомые с Haskell могут рассматривать протоколы как некоторое подобие типов
классов (typeclasses) в этом языке, правда при этом нельзя определять реализации по
умолчанию для методов.

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

Добавления в haskell-mode

2011-02-01T21:40:00.001+01:00

На новогодних каникулах сделал давно запланированное добавление к haskell-mode - добавил поддержку для hlint (команда hs-lint) и haskell style scanner (команда hs-scan). Как и в предыдущей реализации, hs-lint поддерживает замену кода на предлагаемый вариант.
Патчи отправлены мейнтейнеру, но пока они не закоммиченны в основной репозиторий, эти изменения доступны в моем форке. Замечания и пожелания приветствуются...

Итоги года...

2010-12-30T17:52:00.003+01:00

Год получился интересным, было много интересных проектов, как на работе, так и вне ее.
Продолжал "развлекаться" с Clojure, что в итоге вылилось в написание большой статьи для журнала "Практика функционального программирования", докладах на MarginCon 2010 и на встрече Munster Java User Group, а также в подкасте у golodnyj (1, 2). Ну и конечно, не обошлось без писания кода для разных проектов (Incanter, leiningen, swank-clojure, clojure-hadoop, и еще паре своих). Правда немного подзабросил Common Lisp и Scheme, но с первым я поработаю во время чтения недавно купленной "Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp".
Очень много читал (соответствующая полка на shelfari, правда список на прочитать еще больше), не в последнюю очередь благодаря покупке iPad, и приобретению электронных книг (много у Manning).
Первый раз был в США (по работе) - была очень полезная поездка. Теперь в планах поездки уже не по работе, хочется вживую познакомиться с френдами на обоих побережьях США...
На следующий год очень много планов:

хочу немного увеличить количество Haskell и Erlang в своих проектах, и может быть посмотреть на Scala, если останется время;
продолжить заниматься machine learning, кроме того, есть несколько задумок в части natural language processing;
продолжу занятия с hadoop, и т.п. вещами, связанными с обработкой больших объемов данных;
обновить существующие статьи по программированию и Emacs, и может быть написать что-то новое для ПФП;
продолжить хакать Emacs, особенно в части CEDET для функциональных языков.

И пользуясь случаем, хочу поздравить всех своих читателей с наступающим новым годом, и пусть у вас будет много интересных вещей в новом году, и вообще все хорошо в жизни :-)

Update: Забыл написать, что в следующем году (марте скорее всего) будет официально издан перевод отличной книжки - Types and Programming Languages. Перевод закончен полностью, и сейчас только ведется работа над версткой

Переехал на el-get

2010-12-21T11:57:00.000+01:00

Я достаточно долгое время таскал с собой все используемые пакеты для Емакса, вместе с конфигурационными файлами - это позволяло мне иметь везде одинаковую рабочую среду. Большая часть используемых пакетов бралась прямо из репозиториев и регулярно обновлялась с помощью набор шельных скриптов.
Но некоторое время назад я наткнулся на проект el-get, который берет на себя вопросы скачивания и обновления пакетов, и делает это прямо из емакса. Основное удобство заключается в том, что в составе el-get имеется большое количество готовых конфигурационных файлов (рецептов) для самых разных пакетов, и вы можете сразу использовать их в своей конфигурации.
Использование el-get очень просто - вы определяет список пакетов, которые вы хотите использовать, а затем вызываете функцию (el-get), которая выкачивает пакет, компилирует его в соответствии с инструкциями, и загружает нужные части, так что пакет становится доступным для использования. Подробности использования можно найти в описании проекта.
Неделю назад я наконец-то собрался с духом, и перевел свою рабочую конфигурацию на el-get (я пока использую свой форк проекта, хотя многие из рецептов уже внесены в основной проект), пришлось правда добавить рецептов которых еще не было в репозитории, и немного повозиться со сборкой на Mac OS X. Но в остальном - все работает нормально.

Следующие номера ПФП

2010-12-08T14:59:00.000+01:00

Редакция журнала "Практика функционального программирования" ищет авторов статей для следующих выпусков журнала.
Если вы хотите написать о применении ФП в своей работе, о новом языке программирования, о конкретном алгоритме, сделать перевод хорошей статьи, или написать еще о чем-то относящемся к ФП, то пришлите письмо на адрес ie@fprog.ru с небольшим описанием того, о чем вы хотите написать

Дайджест прочитанных книг. Ноябрь 2010

2010-12-08T13:33:00.002+01:00

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

Programming Massively Parallel Processors: A Hands-on Approach

В рамках проверки некоторых гипотез решил ознакомиться с программированием для графических процессоров (GPU). В общих чертах я знал как это делается, а для получения более подробной информации выбрал книжку Programming Massively Parallel Processors: A Hands-on Approach, которая судя по обзорам должна была дать достаточно информации для начала работы с GPU.

Первые две главы содержат введение в историю программирования на GPU, рассматривают их архитектуру, а также описывают разные подходы к параллельному программированию.
Начиная с третье главы начинается описание программирования с помощью CUDA, начиная со структуры программы. Затем показывается простой пример умножения двух матриц, который будет улучшаться на протяжении всей книги. И в заключение третьей главы, рассматриваются необходимые вопросы перемещения данных между основной памятью и GPU, а также то, как соотносятся ядерные функции и потоки выполнения GPU.
Четвертая глава полностью посвящена тому, как организовано выполнение кода в модели CUDA — как потоки выполнения выбираются для исполнения на процессоре, как они образуют блоки потоков, как обеспечить синхронизацию между потоками. В пятой главе рассматриваются все виды памяти доступной для программиста CUDA и описываются различные стратегии ее использования, с учетом влияния на производительность и т.п. вещи.
Шестая глава полностью посвящена вопросам оптимизации производительности программ — как обеспечить полную загрузку процессора и шины по которой данные передаются в память, как организовать предвосхищающую выборку данных, и т.д. В седьмой главе внимание читателя обращается на выполнение операций с плавающей точкой, о том, как это влияет на точность вычислений и т.п. вопросам.
В 8-й и 9-й главах рассматриваются два проекта, которые используют вычисления на GPU. Для каждого проекта рассматриваются архитектура программы, как организованы данные, что выносится в ядерную функцию и т.п.
Десятая глава более философская — в ней пытаются описать общие подходы к решению проблем и выбору алгоритмов для параллельных программ.
А 11-я глава посвящена небольшому описанию языка OpenCL, с указанием отличий его от CUDA. Но описание слишком краткое, и лучше обратиться к официальной документации по OpenCL, хотя сама книга дает очень теоретическую хорошую базу.
Заключение: Если вы хотите ознакомиться с основами "нормального (general purpose)" программирования на графических процессорах, то вы можете взять эту книгу. В ней содержится общая информация об архитектуре, советы по дизайну эффективных программ, которые будут работать на этих процессорах (проиллюстрированные различными примерами), а также небольшое введение в OpenCL. Кроме того, каждая глава книги содержит много ссылок на статьи и литературу, которые могут быть полезны в дальнейшей работе. Для тех кто хочет подробней познакомиться с CUDA, советуют книгу CUDA by Example: An Introduction to General-Purpose GPU Programming и/или официальную документацию.

Дальнейшая работа

Меня в первую очередь интересует OpenCL, поскольку имеется возможность его использования из других языков, а не быть привязанным к C. Например, имеется проект Calx, который обеспечивает возможность запуска кода на OpenCL из программ на Clojure. К тому же, OpenCL поддерживается не только NVidia. Я жду выхода в следующем году книг OpenCL in Action (уже можно начинать читать купив MEAP) и OpenCL Programming Guide, которая, судя по описанию, должна содержать достаточно много полезной информации.
Хорошим подспорьем также является то, что с недавнего времени вы можете запускать свой код использующий GPU в Amazon Elastic Cloud, что позволяет уменьшить расходы на покупку мощного оборудования.

Дополнительные ресурсы

В качестве полезных ресурсов могу указать на сайт GPGPU где регулярно публикуются статьи и анонсы про программирование GPU. Например, для меня были интересны следующие статьи: GrAVity: A Massively Parallel Antivirus Engine и Regular Expression Matching on Graphics Hardware for Intrusion Detection, поскольку они имеют некоторое отношение к тому, чем я занимаюсь.
Как минимум два курса по программированию GPU можно найти на iTunesU. Кроме того, доступен следующий курс лекций.
И достаточно много документации и учебных материалов можно найти на сайте NVidia — как по CUDA, так и по OpenCL.

Интервью для проекта openquality

2010-12-02T20:25:00.000+01:00

На сайте проекта OpenQuality выложили интервью со мной, обо всем понемножку - разработка ПО, функциональные языки, безопасность и т.д. Умудрился упомянуть про Emacs всего один раз ;-)

6-й номер журнала "Практика функционального программирования"

2010-11-30T13:52:00.000+01:00

После долгого перерыва вышел новый номер журнала "Практика функционального программирования". В новом номере опубликованы интервью с Саймоном Пейтон Джонсом и Джо Армстронгом, а также несколько интересных статей.
Кроме того, выпущена бумажная версия журнала. Подробнее об этом, в официальном анонсе!

Рабочее/файл-форматное 2

2010-11-12T11:02:00.000+01:00

Как и было обещано, Microsoft опубликовал видео сделанное на лекциях о форматах файлах, о которых я писал в предыдущем посте. Тем, кто работает с офисными форматами файлов, будет интересно

Рабочее/файл-форматное

2010-11-04T14:36:00.000+01:00

Две недели назад я побывал на семинаре в Microsoft (в офисе в Редмонде) посвященном работе с файлами Microsoft Office. Поскольку я давно общаюсь с соответствующими подразделениями Microsoft на темы работы с различными форматами файлов, то было очень интересно познакомиться как с людьми, которые готовят документацию по протоколам и форматам файлов, так и с самими разработчиками Microsoft Office.
Семинар длился два дня, в течении которых разработчики MS Office рассказывали про внутреннее устройство разных частей Office, и как они соотносятся с тем, что сохраняется в файлах. Кроме того, была возможность задать свои вопросы напрямую разработчикам и людям, отвественным за документацию.
Поскольку такой семинар проводился впервые, то внешних разработчиков было не особо много (человек 15 из разных компаний), но было много представителей Microsoft, и обстановка была "рабочей", т.е. ответы на задаваемые вопросы получались практически сразу, что было очень полезно - можно было показать проблемные файлы, обсудить куски кода и т.п.
Channel9 должен вскоре опубликовать видео с прочитанными лекциями, и как только они появятся, я напишу дополнительно. Кроме того, был создан отдельный блог, в котором будут публиковаться анонсы о будущих семинарах, посвященных работе с файлами Microsoft Office, и сопуствующим тематикам. И я надеюсь, что в будущем такие семинары будут проводиться и в Европе - все-таки достаточно тяжело добираться в центральный офис MS...
P.S. хотелось бы отметить, что за последние два года документация по форматам файлов и протоколам очень сильно улучшилась, что не может меня не радовать, поскольку уже устал заниматься reverse engineering...

Дайджест прочитанных книг. Октябрь 2010

2010-11-04T14:15:00.003+01:00

Pro Git

Так получилось, что я использую Git достаточно давно, с времен когда книг по нему еще не было, но тут наткнулся на эту книжку и решил ее прочитать на предмет обнаружения неизвестных тем. Книга имеет отдельный сайт где доступна полная версия книги в виде HTML (есть еще и версия в epub), а также имеется блог где попадаюются интересные заметки. А исходники книги, вместе с примерами доступны на github.

Книга начинается с краткого обзора Git, зачем он был создан, истории и т.п. вещей. Есть небольшой раздел посвященный установке и первоначальной настройке Git.
Во второй главе повествование переходит к использованию Git, начиная с простейших вещей, типа внесения (commit) изменений, просмотра истории изменений, отмене изменений и т.п. вещам. Также даются необходимые сведения по работе с удаленными (remote) репозиториями. Третья глава полностью сосредоточена на вопросах, связанных с созданием веток (branching), начиная с простых команд для создания веток и переключения между ними, и заканчивая достаточно подробным описанием использования rebase. Отдельный раздел посвящен возможным схемам разработки используя несколько веток.
4-я глава посвящена вопросам создания удаленного репозитория Git, включая рассмотрение доступных протоколов, предоставление публичного доступа к серверу, а также рассматриваются различные утилиты, предназначенные для упрощения создания разделяемых репозиториев, таких как Gitosis, Gitolite и т.д. А 5-я глава посвящена вопросам использования Git для коллективной разработки, начиная с рассмотрения различных подходов к организации разработки (доступ к общему репозиторию, выделение отдельной роли интегратора изменений, и т.п.), и рассматривая отдельно роли контрибьютора и мейнтенера проекта.
В 6-й главе рассматриваются различные "нестандартные" вопросы использования Git, которые реже встречаются в работе — использование внешних модулей в репозитории, слияние под-деревьев, переписывание истории изменений и т.п. 7-я глава достаточно подробно рассматривает вопросы настройки Git, включая создание хуков. А 8-я глава посвящена вопросам интеграции Git и SVN, а также вопросам миграции на Git с других систем контроля версий.
И заканчивается книга главой о внутреннем устройстве Git, как хранятся объекты и прочая информация, как эта информация передается используя различные протоколы и т.д.
Заключение: хорошее введение в Git, рекомендуется для тех, кто собирается начать использовать Git. А те, кто уже работает с Git тоже могут найти что-то интересное в книге, например, описание утилит для организации репозиториев, или другую полезную информацию.

Data-Intensive Text Processing with MapReduce

В свободное время (а иногда и на работе) я развлекаю себя различными задачами для решения которых нужно обрабатывать большие объемы данных. В качестве платформы был выбран Hadoop, и задачки пишутся с использованием clojure-hadoop и других утилит.

Я уже писал про книгу "Hadoop: The Definitive Guide" (кстати, сейчас вышло второе издание, которое было обновлено описанием свежих версий Hadoop), но в отличии от этой книги, книга Data-Intensive Text Processing with MapReduce не описывает детали программирования для Hadoop или какой-то другой системы основанной на принципах Map/Reduce, а посвящена вопросам проектирования алгоритмов которые будут выполняться в таких системах. В книге также рассматриваются реализации известных алгоритмов, таких как создание инвертированных индексов для поиска, адаптированных для параллельной обработки данных. У данной книги есть отдельный сайт, где вы можете найти дополнительную информацию, а также свободно скачать бета-версию книги. Кроме того, для экспериментов с алгоритмами, описанными в книге, авторы создали библиотеку Cloud9, которую вы можете использовать в своей работе.
Книга начинается (глава 1) с небольшого описания основных концепций Map/Reduce, как задания выполняются в фреймворке, как происходит разделение задач между mappers & reducers. Кроме того, приводится небольшое описание основных подсистем Hadoop, чтобы читателю было понятно как происходит распределение заданий, хранение обрабатываемых данных и т.п. вещи.
Вторая глава рассматривает различные подходы к реализации алгоритмов для Map/Reduce, начиная с наивных реализаций, и затем рассматривая вопросы оптимизации алгоритмов (например, путем объединения результатов прямо в mapper, или использования дополнительных combiners), сортировку результатов, объединение результатов (joins), и т.д.
Глава 3 показывает как можно в рамках Map/Reduce реализовать генерацию инвертированного индекса, который используется при поиске по документам. Сначала приводится наивная реализация генерации индекса, которая оптимизуется в следующих главах, вводя возможность сжатия индекса и т.п. вещи.
4-я глава полностью посвящена реализации алгоритмов на графах в рамках Map/Reduce. В качестве первого примера рассматривается поиск кратчайших путей в графе, и показана реализация для этой задачи, вместе с описанием недостатков, присущих параллельной реализации. А в качестве второго примера используется вычисление PageRank для набора страниц. И в последнем разделе этой главы рассматриваются проблемы, которые возникают при обработке графов при помощи Map/Reduce и даются ссылки на дополнительную литературу.
В 5-й главе рассматривается использование Map/Reduce для решения задач machine learning на примере одного из класса алгоритмов — expectation maximization. В первом разделе главы описываются сами алгоритмы expectation maximization, а в следующих разделах описывается hidden markov models как класса задач, к которому применимы алгоритмы expectation maximization, и затем показывается реализация expectation maximization на базе Map/Reduce.
И в заключении авторы вкратце рассматривают недостатки парадигмы Map/Reduce и рассматривают альтернативные подходы к масштабным вычислениям.
Заключение: Если вы программируете для Hadoop или другой системы Map/Reduce (включая самописные), то книжку читать обязательно — в ней достаточно много советов по "правильной" организации обработки данных. Кроме этого, в конце книги имеется внушительная библиография, которая может послужить отличным источником дополнительной информации по соответствующим темам.

Дайджест прочитанных книг. Сентябрь 2010

2010-10-07T14:52:00.000+01:00

Мне пришла в голову идея, что было бы полезно делиться достаточно подробными впечатлениями о прочитанных книгах. Хотя я и пользуюсь GoodReads и Shelfari, но обзоры там делаю на английском и достаточно краткие. В качестве периода между обзорами выбран месяц, что дает мне возможность прочитать 2-4 книги, про которые стоило бы рассказать :-)

The Joy of Clojure: Thinking the Clojure Way

Я купил The Joy of Clojure: Thinking the Clojure Way (авторы Michael Fogus и Chris Houser) почти сразу после того, как она появилась на сайте Manning, и регулярно получал обновления для него. Но примерно месяц назад пришла полная версия книги (но без окончательной вычитки редактором и красивой верстки), и я сел за ее чтение в полном объеме. У этой книги имеется отдельный сайт на котором можно найти дополнительную информацию о книге, включая информацию о существующих скидках на предварительную версию (MEAP).

Хочется сразу отметить, что это не учебник по языку Clojure, и хотя в книге имеется отдельная глава с кратким (около 30 страниц) описанием основ языка, но все равно, для начала стоит прочитать одну из существующих книг: Practical Clojure или
Programming Clojure, или еще не выпущенную, но уже доступную через MEAP,
Clojure in Action.

Книга пытается рассказать о том, как "более правильно" программировать на Clojure с точки зрения стиля языка и функционального программирования, как лучше организовывать программы на Clojure. Сюда относятся использование "ленивых" структур данных, когда нужно и можно использовать макросы, как организовывать рекурсивное выполнение, как организованы различные структуры данных, когда их нужно и можно использовать, и т.п.

Также достаточно много места уделено вопросам производительности программ на Clojure — какие структуры данных лучше использовать в различных ситуациях, как можно улучшить производительность с помощью type hinting, использования "переходных" структур данных, "блочных" последовательностей и мемоизации.

Не обойден стороной и вопрос конкуррентного программирования на Clojure, и использование изменяемых данных в программах. Обсуждению этих вопросов посвящена 11-я глава книги, в которой обсуждается устройство изменяемых структур (refs/atoms/agents), когда их можно и нужно использовать, а также рассказывается про параллельное программирование на Clojure (futures, promises, локи и т.п.).

Кроме того, книга касается вопросов использования мультиметодов, протоколов и типов данных, введенных в Clojure 1.2, а также вопросов интеграции с JVM и Java. Но эти темы рассматриваются не настолько подробно, как остальные.

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

Lucene in Action, 2-е издание

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

Начинается книга (глава 1) с небольшого обзора Lucene и из чего она состоит, описываются основные этапы в жизненном цикле поиска — сбор документов, выделение информации, индексация, и сам поиск. Кроме того, в 1-й главе приведены небольшие, но законченные примеры того, как можно выполнять индексацию документов и затем использовать полученный индекс для поиска.

Первая часть книги (главы 2-6) посвящены подробному описанию того, как Lucene устроена, и как можно использовать ее возможности в приложениях. Глава 2 полностью посвящена вопросам индексации с описанием того, какие есть опции индексации, как они влияют на работу Lucene, включая производительность, как можно производить индексацию численных и временных (temporal) данных, как можно оптимизовывать и отлаживать процесс индексации.

Глава 3 описывает использование основных поисковых возможностей Lucene. Глава начинается с простого приложения, которое используется в качестве основы для остальных примеров. Сначала рассматривается использование IndexSearch, который используется для выполнения поиска, а затем уже рассматриваются основные виды запросов, реализованных в Lucene, и QueryParser.

Главы с 4-й по 6-ю посвящены "расширенным" темам, их можно пропустить при первом прочтении, если вам нужны только стандартные возможности Lucene. В 4-й главе описываются различные анализаторы текста, реализованные в Lucene и Nutch, а также показывается как можно реализовать новые анализаторы и/или расширять существующие. 5-я глава посвящена дополнительным возможностям поиска — запросам по нескольким полям и/или индексам, использовании векторов терминов (term vectors), сортировке результатов и т.п. А в 6-й главе рассказывается о том, как можно расширить возможности поиска путем реализации собственных методов сортировки, фильтров и "сборщиков" (collectors) документов.

Вторая часть книги (главы 7-11) рассказывает о том, как можно выделять текст с помощью библиотеки Tika (глава 7), какие существуют расширения для Lucene (главы 8-9), как можно использовать Lucene с языками, отличными от Java (глава 10), а 11-я глава рассматривает вопросы администрирования Lucene, и настройки производительности.

Третья часть книги полностью посвящена рассмотрению того, как Lucene применяется в реальных проектах (Kruge, SIREn, LinkedIn) и рассказывается про то, какие возможности Lucene они используют, как организован процесс индексации и поиска, какие расширения были добавлены для работы, и т.д.

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

Introduction to Algorithms

Эту книгу я уже читал много лет назад, в русском переводе (на русском она называется Алгоритмы. Построение и анализ), но некоторое время назад мне захотелось обновить теоретические основы, и поэтому я решил перечитать эту книгу. В руки мне попало 2-е издание, а спустя буквально месяц вышло уже третье издание Introduction to Algorithms, и я немного жалею, что не дождался его, поскольку там есть некоторые полезные темы.

Я не могу много написать об этой книге, иначе это будет ее пересказ :-) Лучше всего о ней говорит оглавление этой книги.

Это классический учебник по алгоритмам и подходам к их анализу. Книга начинается с основ анализа алгоритмов, и затем переходит к рассмотрению различных алгоритмов и структур данных (списки, деревья, хеш-таблицы, кучи и т.д.). Для каждой из рассматриваемых тем приводится анализ сложности алгоритма, рассматриваются возможные варианты реализации структур данных и т.п. Достаточно много места посвящено алгоритмам над графами. Кроме базовых структур данных и алгоритмов, в книге рассматриваются некоторые "сложные" темы — биноминальные кучи, b-trees и т.п. Почти сотню страниц книги занимают приложения, в которых описывается весь математический аппарат, необходимый для чтения этой книги —
теория множеств, основы теории вероятностей, и т.п.

Стоит также отметить, что на английском языке доступны видео-записи лекций по данному курсу которые читались в MIT (они также доступны через iTunesU).

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

Alex Ott's Russian blog about IT-related things

Итоги года...

Про Стэнфордские курсы...

Перевод TaPL в продаже

Еще книжное...

Книга "Типы в языках программирования"

Что нового в Clojure 1.3?

Расширенная поддержка примитивных типов

Улучшения defrecord и deftype

Reflection API

Модульный clojure-contrib

Множественные улучшения производительности

Прочее

Перевод " Learn You a Haskell for Great Good!"

Опрос: название для русской версии Practical Common Lisp

Небольшой книжный обзор

Вкратце о разных книгах

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

Новый номер журнала «Практика функционального программирования»

Monad tutorial для кложуры

Реклама в журнале "Практика функционального программирования"

Дайджест прочитанных книг. Январь 2011

DSLs in Action

Camel in Action

Test-driven development: By Example

Типы и протоколы в Clojure

Что это такое и зачем нужно?

Определение протоколов

Реализация протоколов

Определение типов данных

deftype & defrecord

reify

Дополнительные функции и макросы

Дополнительная информация

Добавления в haskell-mode

Итоги года...

Переехал на el-get

Следующие номера ПФП

Дайджест прочитанных книг. Ноябрь 2010

Programming Massively Parallel Processors: A Hands-on Approach

Дальнейшая работа

Дополнительные ресурсы

Интервью для проекта openquality

6-й номер журнала "Практика функционального программирования"

Рабочее/файл-форматное 2

Рабочее/файл-форматное

Дайджест прочитанных книг. Октябрь 2010

Pro Git

Data-Intensive Text Processing with MapReduce

Дайджест прочитанных книг. Сентябрь 2010

The Joy of Clojure: Thinking the Clojure Way

Lucene in Action, 2-е издание

Introduction to Algorithms

Улучшения `defrecord` и `deftype`

Модульный `clojure-contrib`