Russian Clojure Planet

Готовится перевод "Clojure Programming"

Alex Ott — Fri, 11 Jan 2013 09:40:00 +0000

Издательство "ДМК-Пресс" продолжает серию переводов книг про новые языки программирования, и следующая вещь в списке - "Clojure Programming". Перевод уже начался, и они ищут людей которые помогут с технической вычиткой перевода. Если кому-то интересно, то пишите на dm at dmk-press.ru.

Выступление про Clojure на ITSea 2012

Alex Ott — Tue, 25 Sep 2012 16:24:00 +0000

На прошлой неделе я рассказывал про Clojure на небольшой конференции ITSea (совмещенной с купанием в море и т.п. :-), и затем еще давал небольшой мастер-класс на тему практического использования Clojure. Слайды доступны на slideshare (а вот записи выступления к сожалению не было):
Данный постинг является дополнением к этим слайдам, и содержит ссылки на разные ресурсы, упоминавшиеся в рассказе:

Сайт языка
Список доступных книг про Clojure (разделы про конкретные языки в обзоре литературы по ФП)
Введение в Clojure на русском языке
Список видео-лекций и презентаций про Clojure
Planet Clojure - аггрегатор блогов
Getting started with Clojure - описание первых шагов, включая установку и настройку средств разработки
Интерактивные ресурсы/учебники: 4Clojure, TryClojure, Himera, labrepl
Списки рассылки: clojure, clojure-russian
IDE/редактора (остальные редактора/IDE описаны в подразделах Getting Started): Eclipse, IntelliJ IDEA
Средства сборки: поддержка Clojure в Maven, Leiningen
Библиотеки/фреймворки:
- Web: Ring, Compojure, Noir, Hiccup, lein-ring, ClojureScript, ClojureScript One, lein-cljsbuild
- SQL: Korma, clojure.java.jdbc
- NoSQL: Monger (MongoDB), Clutch (CouchDB), clojure-hbase-schemas (HBase)
- GUI: Seesaw
- core.logic
- Contrib libraries
Внутреннее устройство persistent коллекций: вектора, отображения (maps)

Clojure 1.4!

Alex Ott — Sun, 15 Apr 2012 18:46:00 +0000

А между тем, незаметно подкрался релиз новой версии языка Clojure - 1.4.
Rich Hickey называет этот релиз в основном maintenance, хотя есть и достаточно крупные изменения:

Расширяемая процедура чтения (reader) - разработчик может указать функцию чтения для своих типов данных. Разработчик должен указать метку для своего типа данных, и соответствующую функцию чтения, и данная функция будет вызвана после того, как следующая (после метки) форма будет считана стандартным reader. Например, можно будет писать вот так: #foo/bar [1 2 3] - в этом случае, после чтения метки, процедура чтения сначала считает форму [1 2 3], а затем вызовет процедуру связанную с данной меткой (если она определена) и передаст ей прочитанные данные. В состав новой версии вошла поддержка чтения двух новых типов - #inst - для времени и даты, и #uuid - для UUID.
Новый синтаксис для доступа к полям записей (унифицировано с ClojureScript) - теперь можно писать (.-field_name record-instance).
Возможность контролировать поведение компилятора Clojure с помощью опций, указанных через переменную *compiler-options*.

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

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

Alex Ott — Sat, 24 Sep 2011 16:14:00 +0000

Сегодня ночью была выпущена новая версия языка 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 если вызвана без параметров;
Возможность указания разных возвращаемых типов в объявлениях одной функции с разными количествами аргументов;
Некоторые функции перемещены в другие пространства имен;

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

Alex Ott — Thu, 07 Apr 2011 09:40:00 +0000

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

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

Alex Ott — Wed, 09 Feb 2011 19:08:00 +0000

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

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

Alex Ott — Fri, 04 Feb 2011 15:19:00 +0000

Эта заметка также опубликована как часть статьи "Введение в 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 может использоваться в тех случаях, когда вы хотите использовать одни и те
же реализации для разных типов данных — в этом случае, вы можете создать отображение
с нужными функциями, и использовать его для разных типов, например, как описано в
следующем блог-постинге.

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

Alex Ott — Thu, 07 Oct 2010 14:52:00 +0000

Мне пришла в голову идея, что было бы полезно делиться достаточно подробными впечатлениями о прочитанных книгах. Хотя я и пользуюсь 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 — Wed, 15 Sep 2010 08:09:00 +0000

Почти через месяц после первой части, Антон (ака golodnyj) выложил вторую часть подкаста со мной, в которой рассказывается про язык Clojure.

Вышла Clojure 1.2

Alex Ott — Thu, 19 Aug 2010 16:52:00 +0000

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

добавлены протоколы (protocols) и типы данных (datatypes), позволяющие создавать новые абстракции и полиморфные функции. При этом производительность гораздо выше чем при использовании мультиметодов;
расширена деструктуризация структур данных, о которой я уже писал;
в составе языка введено несколько новых пространств имен, функции которых были перенесены из clojure-contrib. Сюда относятся функции для работы со строками, repl, pretty printer, ввод/вывод Java, и т.д.;
расширен набор функций для работы с последовательностями;
добавлена поддержка аннотаций Java, что позволяет использовать соответствующий функционал различных фреймворков;
много изменений, связанных с улучшением производительности кода;
для указания метаданных теперь вместо #^ используется просто ^.

Полный список изменений можно найти в репозитории языка. Также полезной может быть презентация Michael Fogus о новых возможностях.

P.S. я успел только частично обновить Введение в Clojure (это обновленная версия статьи из 4-го номера ПФП) описанием функциональности из версии 1.2. Сейчас не хватает описания протоколов и типов данных. Я надеюсь, что допишу этот кусок за выходные, о чем сделаю отдельный анонс

Подкастовое

Alex Ott — Tue, 17 Aug 2010 12:35:00 +0000

Дебютировал в подкасте у golodnyj. Это первая часть в которой мы общаемся на тему функционального программирования и лиспа. Вторая часть (через несколько дней) будет про язык Clojure...

Русская планета Clojure

Alex Ott — Wed, 11 Aug 2010 15:28:00 +0000

Я сделал (пока с помощью Yahoo! Pipes) агрегатор русскоязычных блогов, посвященных Clojure. Все заведено через feedburner, так что будущие изменения в хостинге не будут влиять на подписчиков.
Если кто пишет про Clojure на русском - пишите мне, с ссылками на блог - я сразу добавлю.
Update 1: Что-то Yahoo! Pipes выставляет неправильные ссылки на оригинальные посты - разбираюсь с ним
Update 2: Починил

Деструктуризация параметров в Clojure

Alex Ott — Fri, 06 Aug 2010 15:14:00 +0000

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

Если вы передаете сложные структуры данных в функции (defn или fn), или связываете значения с символами в let, то вы можете использовать встроенную в Clojure деструктуризацию параметров, что позволяет связывать части структур данных с символами. Это значительно упрощает (и сокращает) код, поскольку вам не нужно писать явный код для получения значения значений из массивов или отображений.

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

user> (let [ [a b] [1 2]]
  (list a b))
(1 2)
user> (let [ [a b] [1]]
  (list a b))
(1 nil)
user> (let [ [a b] [1 2 3 4]]
  (list a b))
(1 2)
user> (let [ [a b & c] [1 2 3 4]]
  (list a b c))
(1 2 (3 4))
user> (let [ [a b & c] "abcde"]
  (list a b c))
(\a \b (\c \d \e))
user> ((fn [ [a b] ] (list a b)) [1 2])
(1 2)
user> (defn dfunc1 [ [a b] ]
  (list a b))
user> (dfunc1 [1 2])
(1 2)

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

user> (let [{a :k1 b :k2 c :k3} {:k1 1 :k2 2 :k3 3}]
  (list a b c))
(1 2 3)
user> (let [{a :k1 b :k2 c :k3} {:k1 1 :k3 3}]
  (list a b c))
(1 nil 3)

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

user> (let [{a :a b :b c :c :or {a 1 b 2 c 3}} {:a 4}]
  (list a b c))
(4 2 3)

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

user> (let [{:keys [a b c]} {:a 1 :b 2 :c 3}]
  (list a b c))
(1 2 3)
user> (let [{:keys [a b c]} {:a 1 :c 3}]
  (list a b c))
(1 nil 3)

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

user> (let [{:strs [a b c] :as m :or {a 2 b 3}} {"a" 5 "c" 6}]
  (list a b c m))
(5 3 6 {"a" 5, "c" 6})

user> (let [{:syms [a b c] :as m :or {a 2 b 3}} {'a 5 'b 6}]
  (list a b c m))
(5 3 6 {"a" 5, "c" 6})

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

(defn имя-функции [обязательные параметры
         & {:keys [необязательные параметры]
            :or {значения по умолчанию}}]
тело функции)

например,

user> (defn dfunc2 [a b & {:keys [c d] :or {c "c" d "d"}}]
  (list a b c d))
user> (dfunc2 1 2 :c 3)
(1 2 3 "d")

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

user> (let [[a b :as c] [1 2 3]]
  (list a b c))
(1 2 [1 2 3])
user> (let [{a :a b :b :as c} {:a 1 :b 2 :c 3}]
  (list a b c))
(1 2 {:a 1, :b 2, :c 3})

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

user> (let [ [a [b c]] [1 [2 3]]]
  (list a b c))
(1 2 3)
user> (let [ [a [b c]] [1 2]]
  (list a b c))
Error....
user> (let [{a :a {c :c d :d} :b} {:a 1 :b {:c 3 :d 4}}]
  (list a c d))
(1 3 4)

Но тут стоит быть осторожным, поскольку если вместо вектора вы передадите объект несовместимого типа, то вы получите ошибку, как во втором примере.
Дополнительные примеры вы можете найти на данной странице. Также хорошее описание деструктуризации параметров можно найти в книге "Clojure in Action".

Статья про Clojure & Hadoop

Alex Ott — Fri, 23 Jul 2010 09:58:00 +0000

Наконец-то закончил давно начатую и откладываемую статью про использование Clojure для программирования Hadoop. В статье описывается пакет clojure-hadoop, который позволяет сильно упростить программирование заданий для Hadoop.

P.S. English version will follow after short time, that I need to make translation ;-)

Список рассылки про Clojure на русском

Alex Ott — Wed, 21 Jul 2010 07:53:00 +0000

Вчера был создан список рассылки для обсуждения вопросов о Clojure на русском языке. Кто заинтересован - присоединяйтесь!

Презентация про Clojure с MarginCon 2010

Alex Ott — Sun, 11 Jul 2010 19:52:00 +0000

В конце июня я делал доклад про Clojure на конференции MarginCon (через Skype), а сегодня я выложил презентацию синхронизированную со звуком. Огромное спасибо Юре Юревичу за предоставленную запись и за возможность выступления на этой конференции...
P.S. звук немного гуляет, в нескольких местах опущено по несколько секунд выступления, но в целом не должно быть проблемы с остальным текстом

Впечатления о Practical Clojure

Alex Ott — Fri, 09 Jul 2010 10:19:00 +0000

Вчера, практически в один заход прочитал Practical Clojure - хотелось ознакомиться с новой книгой, чтобы составить свое мнение.
Что я могу сказать о ней после прочтения? Это краткое и очень хорошее введение в язык Clojure - в книге есть вся необходимая информация для того, чтобы начать работу с языком, включая описание таких эксперементальных вещей, как протоколы и типы данных.
Кроме того, в книге достаточно много диаграм и схем, которые облегчают понимание структур и потоков данных в Clojure. Также, в книге достаточно много места посвящено объяснению концепций state/identity и тому, как они применяются внутри Clojure.
Среди недостатков можно отметить отсутствие больших примеров, таких как Lancet в Programming Clojure, а также нет никакой информации средам разработки и т.п. вещам, так что эту информацию надо искать в других источниках.

Небольшой опрос

Alex Ott — Wed, 09 Jun 2010 09:45:00 +0000

Решил сделать небольшой опрос на тему книг про Clojure. Это не значит, что я собираюсь писать книгу, но я думаю в этом направлении...
Update: Ссылка на опросник, если вам неудобно заполнять его на blogspot...

Loading...

P.S. просьба попиарить этот опросник, особенно среди ява-программистов...

Видео-материалы про Clojure (продолжение)

Alex Ott — Tue, 27 Apr 2010 14:39:00 +0000

Собрал ссылки на видео-материалы о кложуре на отдельной странице на своем сайте - собираюсь регулярно обновлять этот список по мере появления новых материалов.

Leiningen + Clojure

Alex Ott — Wed, 14 Apr 2010 12:46:00 +0000

Написал еще одну заметку про сборку кода написанного на Clojure. В ней рассматривается использование утилиты Leiningen, написанной на Clojure, и которая намного проще Maven для небольших проектов.

Использование Maven для сборки кода на Clojure

Alex Ott — Wed, 07 Apr 2010 18:14:00 +0000

Написал и выложил на свой сайт небольшую заметку про использование Maven для сборки и тестирования кода, написанного на Clojure. Замечания просьба оставлять прямо на сайте...
P.S. Следом планируется публикация заметки про Leiningen, может быть закончу до конца недели

Более простое начало работы с Clojure

Alex Ott — Tue, 23 Mar 2010 21:28:00 +0000

Stuart Halloway (автор книги Programming Clojure) разрабатывает проект labrepl, который предназначен для упрощения начала работы с Clojure. Проект содержит различные примеры использования Clojure и позволяет достаточно просто установить среду в которой можно эксперементировать с этим языком, используя разные библиотеки - clojure-contrib, incanter, compojure и используя разные среды разработки и средства сборки проектов.

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

Alex Ott — Thu, 25 Feb 2010 17:06:00 +0000

Выпущен новый, 4-й номер журнала "Практика функционального программирования". В новом номере вы можете почитать о производительности Lisp'а, о свертках, мономорфизме и бесточечном стиле программирования на Haskell, а также моя статья о языке Clojure.
Статья получилась не особо короткая (больше 30 страниц), но она должна содержать все необходимые материалы для начала работы с этим языком - я надеюсь, что их будет достаточно и для людей не знакомых с Lisp.
Я также хотел бы поблагодарить людей, помогавших мне в написании этой статьи за их комментарии и советы

Презентация про Incanter

Alex Ott — Fri, 12 Feb 2010 08:29:00 +0000

В блоге проекта Incanter выложена презентация о работе с наборами данных и графиками. Incanter - R-подобная среда и набор библиотек для Clojure для статистической обработки данных. Кроме того, существует проект RIncanter, который реализует взаимодействие между R и Clojure/Incanter.

Видеоматериалы про Clojure

Alex Ott — Tue, 26 Jan 2010 14:52:00 +0000

Поскольку не вся информация помещается в статью, то решил публиковать в блог излишки информации :-)
Существует несколько хороших наборов видеоматериалов, посвященных Clojure:

http://clojure.blip.tv/ - содержит видео с рассказами о Clojure, записанные на выступлениях как автора языка - Rich Hickey, так и других разработчиков. Лекции самые разные по содержанию, и содержат интересные выступления. Есть отдельные лекции "Clojure для программистов на Lisp" и "Clojure для программистов на Java", которые могут служить очень хорошими введениями в язык;
набор скринкастов от Sean Devlin, в которых рассказывается как про возможности новой версии Clojure - 1.1, так и про другие темы - управление проектами, и т.д.
Inside Clojure - лекция Rich Hickey для Channel 9, в котором рассказывается про внутреннее устройство языка

Update: Спасибо комментаторам за дополнительные ссылки, я про них совсем забыл:

Persistent Data Structures and Managed References - еще одна презентация Rich Hickey о внутреннем устройстве Clojure
Intro to Clojure - серия презентация о Clojure;
Functional Programming with Clojure - платный скринкаст, показывающий возможности Clojure на примере разработки игры (я сам не смотрел его, в отличии от предыдущих материалов)...

Applicative-order evaluation vs Normal-order evaluation

Vladimir Dolzhenko — Sun, 31 Oct 2010 18:03:00 +0000

Нормальным порядком вычисления (normal-order evaluation), если кратко, можно назвать такой порядок вычисления, что сперва происходит «полная подстановка, затем редукция».

Аппликативный порядок вычисления (applicative-order evaluation), напротив, сперва происходит «вычисление аргументов, затем вызов процедуры».

В качестве наглядного примера - попробуем реализовать свою собственную функцию and для clojure.

(defn
  #^{:test (fn []
 (assert (true? (my-and true)))
 (assert (false? (my-and true false)))
 (assert (true? (my-and true true)))
 (assert (false? (my-and true true false)))
 (assert (true? (my-and true true true)))
)}
  my-and 
  ([x] x)
  ([x & more] (if (false? x) x (reduce my-and more)))
)

Отлично.

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

В группе языков lisp, как впрочем и во многих других языках, используется аппликативный порядок вычисления (в общем случае, если не используются мощности «синтаксического сахара»).

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

В качестве примера используем функцию foo:

user=> (defn foo[x] (do (println "foo") x))
user=> (my-and (foo false) (foo false) (foo true))
foo
foo
foo
false
user=> (and (foo false) (foo false) (foo true))
foo
false

P.S. Строго говоря, and не использует нормальный порядок вычисления, а «псевдонормальный порядок» на один шаг.

FP-approach in Java via Goolge Collections

Vladimir Dolzhenko — Sun, 28 Mar 2010 23:50:00 +0000

I'm going to demonstrate some elements of functional programming (fp) approach in java.

For this purpose I use Google Collections Library - provides new and elegant collection types as well as some fp elements and techniques.

A bit more about Google Collections Library:
Google Collections Library FAQ
What is the Google Collections Library?
Introduction to Google Collections by Benjamin Winterberg

For obvious cases I put examples in clojure and in java using fp-approach techniques.

Took short and nice example from "Programming clojure" book - StringUtils.isBlank() is the method (from the Apache Commons) checks to see whether a string is blank: either empty or consisting of only whitespace :

public static boolean isBlank(String str) {
  int strLen;
  if (str == null || (strLen = str.length()) == 0) {
    return true;
  }
  for (int i = 0; i < strLen; i++) {
    if ((Character.isWhitespace(str.charAt(i)) == false)) {
      return false;
    }
  }
  return true;
}

Here is a similar implementation in Clojure:

(defn blank? [s] (every? #(Character/isWhitespace %) s))

Java-fp-approach implementation of isBlank method powered by google collections, string is a sequence of chars - that's why I had introduce stringIterator:

import static ru.dolzhenko.lambda.iterators.StringIterator.*;

import static com.google.common.collect.Iterators.*;

public static boolean isBlank(String str) {
return all(stringIterator(str),
  new Predicate<Character>() {
    @Override
    public boolean apply(Character ch) {
      return Character.isWhitespace(ch);
    }
  });
}

map is function mapping, a classic primitive in functional programming - apply a function to all elements of a list, and return the resulting list.

e.g. parse string values to numbers:

(map #(Integer/valueOf %) ["1" "2" "3"])

on java:

Collections2.transform(
  ImmutableList.of("1", "2", "3"), 
  new Function<String, Integer>() {
    @Override
    public Integer apply(String from) {
      return Integer.valueOf(from);
    }
  });

Transform is also available for Iterables.transform(Iterable, Function), Iterators.transform(Iterator, Function) etc.

The reduce function is a little less obvious in its intent. This function reduces a list to a single value by combining elements via a supplied function.

The filter function returns elements of collection that satisfy predicate.

For instance, Let's solve ProjectEuler - Problem #1 - find the sum of all the multiples of 3 or 5 below 1000:

(reduce + (filter #(or (zero? (mod % 3)) (zero? (mod % 5))) (range 1000)))

... and the same on java:

// import static import static com.google.common.base.Predicates.*;
// import static com.google.common.collect.Iterators.*;

// import static ru.dolzhenko.lambda.iterators.LambdaIterators.*;
// import static ru.dolzhenko.lambda.functions.LambdaFunctions.*;
// import static ru.dolzhenko.lambda.functions.LambdaPredicates.*;

final BigDecimal value = reduce(sum(), filter(range(1000),
  or(
    zero(mod(new BigDecimal(3))),
    zero(mod(new BigDecimal(5)))
  )));

Yeah, there are no reduce and range functions in google collections too, so I had to ~~build my own theme park, with blackjack~~ make my own collection of functions LambdaIterators & Co. that supplement google collections with such useful functions as reduce, range, take, takeWhile, iterate, first, rest.

Definitely, Predicate is a function, so it can be described as

public interface Predicate<T> extends Function<T, Boolean>{ 
}

To avoid autoboxing overhead authors of google collections prefer to introduce new interface.

After that we able to construct expressions like

(take 5 (filter even? (iterate inc 1)))

on java:

take(5, filter(iterate(inc(), BigDecimal.ONE), even()))

as well as for finite collection as well as for infinite collection - functions
filter, transform, take, takeWhile, iterate, first, rest are lazy - in other words, elements are not calculated until they are needed.

btw. lambdaj is useful framework that provides pseudo fp approach in java.

Задачка: A(4,3)

Vladimir Dolzhenko — Fri, 26 Feb 2010 12:56:00 +0000

функция A(x,y) определена как
A(0,y) = 1, y ≥ 0
A(1,0) = 2
A(x,0) = x + 2, x ≥ 2
A(x + 1, y + 1) = A( A(x, y + 1), y), x ≥ 0, y ≥ 0

A(4,3) = ?

Данная функция есть функция Аккермана - простой пример вычислимой функции, которая не является примитивно рекурсивной.

F(z) = A(4, z)

Попытки вычислить A(4, 3) в лоб обречены на провал (код на clojure):

(defn A([x y]
 (cond 
  (zero? x) 1
  (and (= x 1) (zero? y)) 2
  (and (>= x 2) (zero? y)) (+ x 2)
  :else (recur (A (dec x) y) (dec y))
 )
))

Однако, на erlang прямо в лоб решается запросто:

-module(ack).
-export([a/2]).

a(0,_) -> 1;
a(1,0) -> 2; 
a(X,0) -> X+2;
a(X,Y) -> a( a(X-1,Y), Y-1).

запускаем...

$ erl
1> c(ack.erl).
{ok,ack}
2> ack:a(4,3).
ответ скрыт

Решить данную задачу на clojure вполне реально - дерзайте!

Level 1

ps. Я тем временем заработал Level 1 на Project Euler - на мой взгляд, отличный способ прокачать навыки в функциональном программировании.

Задачка: Робот на бесконечной лестнице

Vladimir Dolzhenko — Thu, 04 Feb 2010 08:34:00 +0000

На бесконечной лестнице находится робот у которого есть API - подняться вверх. Однако не всякая попытка поднятся вверх заканчивается успехом - робот может как поднятся на верх на 1 ступеньку - функция API вернёт 1 - или съехать ниже на 1 ступеньку - возвращаемое значение -1.

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

Задачка скорее разминка для хвоста в целях попрактиковаться на clojure

Clojure - Hello world!

Vladimir Dolzhenko — Thu, 28 Jan 2010 13:22:00 +0000

Подсадил меня один хороший человек на Clojure - диалект Lisp, работающий в JVM.

Язык очень интересный, функциональный, особенно интересен после многолетнего использования объекто-ориентированной парадигмы.

Как же выглядит традицоинный ~~Hello, world !~~ ряд Фибоначчи на clojure ?

(defn fib [n]
"Calculate n-th item of Fibonacci sequence"
(if (= n 0) 1
    (if (= n 1) 2
      (+ (fib (- n 2)) (fib (- n 1))))))

пробуем:

user=> (map fib (range 10))
(1 2 3 5 8 13 21 34 55 89)

Однако, если мы попробуем найти хотя бы 50ый элемент, то... наша попытка обречена на провал - мы впадём в оооочень глубокую рекурсию.

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

(defn fib
"Calculate n-th item of Fibonacci sequence"
([n]
  (if (zero? n) 1
    (if (= n 1) 2
      ((fn
        [n v2 v1] ; v2 = fib(n-2), v1 = fib(n-1) 
        (if (zero? n) (+ v2 v1)
          (recur (dec n) v1 (+ v2 v1))))
       (- n 2) 1 2)))))

вуаля:

user=> (map fib (range 20))
(1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946)
user=> (fib 100)
354224848179261915075
user=> (fib 500)
139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125

updated. наиболее красивое решение, определяющее рекурсивно последовательность:

(def fibs (lazy-cat [1 2] (map + fibs (rest fibs))))


; элементы ряда, которые меньше, чем 100
user=> (take-while #(< % 100) fibs) 
(1 2 3 5 8 13 21 34 55 89)
; первые 10 элементов ряда
user=> (take 10 fibs)
(1 2 3 5 8 13 21 34 55 89)

Матчасть: Programming Clojure by Stuart Halloway

В качестве практического применения можно попробовать решать задачи из Проекта «Эйлер».

ps. После того как сам решил несколько задач нашёл решение первых трёх задач на clojure.

Devclub 2011 # 02. Про лисп.

Sun, 27 Feb 2011 11:35:52 +0000

Mir Lisp'a by Jevgeni Holodkov

оценить можно здесь

Волшебство и Магия Clojure

Mon, 28 Jun 2010 05:25:44 +0000

Сделал перевод lisperati: Casting SPELs in Lisp, адаптированный под Clojure.

Перевод: http://lisperati.planvita.com/

Очень жду комментариев в стиле "ты написал вот так, а пишется вот так" или "написано вот так, но лучше было бы вот так", оставляйте их в комментариях к посту или на github http://github.com/jevgeni/spels-ru/issues. Спасибо!

devclub.eu quiz

Sat, 05 Jun 2010 17:46:19 +0000

На devclub.eu куча решений к quiz-у, который предложил Андрей Солнцев.

Задание: Напечатать на экране следующее:
1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
6-5-4-3-2-1
(Естественно, вместо 6 может быть любое число).

Большинство решений вообщем-то похожи, разница лишь в синтаксисе (и функциях, которые доступны в языке). Все решения стремятся к "one-line solution" ну и благодаря своей динамичности и хорошей библиотеке пока большинством признано решение на Groovy (Сергей Кирьянов):

for ( i in 1..10 ) println( ( i%2 ? 1..i : i..1 ).join('-') );

С моей же точки зрения, если взять за основу, что мы выводим текст на консоль и N не может быть слишком большим, то совершенно гениальным решением является код от Ильи Хямяляйнена (который он кстати сам считает WTF-кодом):

System.out.print("1");
System.out.print("2-1");
System.out.print("1-2-3");
System.out.print("4-3-2-1");
System.out.print("1-2-3-4-5");
System.out.print("6-5-4-3-2-1");

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

Итак, задача сведется к тому, чтобы выводить на экран ряды из цифр, перевернутные через раз. Цифры печатаются через знак "-". Т.е. код может выглядеть так:

(do 
    (println (str-join "-" (range 1 2))) 
    (println (str-join "-" (reverse-range 1 3)))
    (println (str-join "-" (range 1 4)))
    (println (str-join "-" (reverse-range 1 5))) 
    (println (str-join "-" (range 1 6))) 
    (println (str-join "-" (reverse-range 1 7))))

Сделаем это через макросы:

(ns foo
  (:use clojure.contrib.str-utils))
  
(defn reverse-range 
    [start end]
    (reverse (range start end)))

(defmacro ranger
[size]
(let [func (cycle [`range `reverse-range])] 
    (cons 'do 
        (for [step (range 2 (+ 2 size))] 
            `(println (str-join "-" (~(nth func step) 1 ~step)))))))

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

foo> (macroexpand
      '(ranger 3))
(do (clojure.core/println (clojure.contrib.str-utils/str-join "-" (clojure.core/range 1 2))) 
    (clojure.core/println (clojure.contrib.str-utils/str-join "-" (foo/reverse-range 1 3))) 
    (clojure.core/println (clojure.contrib.str-utils/str-join "-" (clojure.core/range 1 4))))

Ну и, собственно, демка (все работает:) ):

foo> (ranger 6)
1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
6-5-4-3-2-1

Clojure video [devclub.eu #04-10]

Mon, 03 May 2010 17:55:07 +0000

Обработал первое (оно же свое) видео с devclub.eu. Изначально тема называлась "(Clojure (как практический лисп) или (как полюбить скобочки))", в процессе подготовки я потерял к ней интерес и стал готовить связку out of tar pit (по управлению сложностью) и clojure в сравнении с другими языками. Добавил в него все, что я когда-то видел, слышал или читал про кложуру. Много примеров взял с блогов авторов книг, которые перечислил в конце. В результате народ ожидал одно, получил другое и был сбит с толку. Вообще - собирал отзывы - очень противоречивые. Было несколько тех, кто знаком с лиспом и сказали, что не понял доклада, были те, кто вообще не в теме - но им понравилось. Вообщем, видимо, получилось что-то явно не простое и сумбурное :) В добавок я путался с терминологией (называл то метод, то функция, то оператор, чем еще больше запутывал). Зато много холиворил и ходил по лезвию - в видео очень много спорных моментов :))

Аккуратно, в этот раз HD - так что трафик и лаги на нетбуках (отключайте HD в плейере). (Link).

Clojure тренинг!

Sun, 14 Mar 2010 18:56:20 +0000

Rubyonline запускает онлайн курс по изучению Clojure. Начинается 24 апреля сего года. Регистрация бесплатна. Для этого нужно зарегистрироваться на сайте RubyLearning.org и потом зарегистрироваться по ссылке Clojure 101 1st Batch с ключом Clojure101. Затем обновить свой профиль и описать себя в нескольких предложениях на форуме.

Больше информации можно найти здесь.

А в это время в рунете про Clojure (06 февраля -> 13 марта 2010)

Sat, 13 Mar 2010 20:58:06 +0000

Ах, лучше поздно, чем.. Повыдергивал самое интересное, что произошло :)

Как установить Clojure/slime с помощью крутой штуки EPLA? (via Holmic). Еще одна статья на русском здесь.. И еще одна здесь (by mkazarian)

Сравнение F#, Clojure и другие функциональные языки. Автор считает первые вполне прагматичными и имеющие потенциал, в отличии от академических поделок (via alexott)

Clojure cheat sheets via MSUGVNUA

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

Отличное видео про Clojure: Functional Concurrency on JVM от Howard Lewis (тот, который tapestry делает) (via anton arhipov)

Машинка Тьюринга на Clojure от Романа zahardzhan Захарова

Хорошая статья по реализации одного из кирпичика Clojure - STM. (via alexott)

Вышла свежая (ну, уже не такая свежая) версия Leiningen, нативный инструмент для сборки кложурных проектов (via zahardzhan)

"It's ok to hate Java, but love JVM" (c) Rich Hickey (via mirocumo)

sorhed рассказал про хаскель, сделав выпад в сторону lisp-а, что было парировано satmech , который привел в сравнение код написанный на Clojure. В суть не вникал, но на Clojure действительно выглядит понятнее :))

Clojure и проект Euler, часть 1 и часть 2

Нашумевшая в отдельных комьюнити статья от Алекса Отта Clojure, или «Вы все еще используете Java? Тогда мы идем к вам!». Алекс систематизировал довольно много информации. Ответа на вопрос "как идиоматически верно программировать на Clojure" там нет, но зато хорошо описываются возможности языка. Есть с чего начать. Ну и переодически есть сравнения с Common Lisp-ом, который, по моему мнению, выглядит грустно на фоне Clojure :)

Математическая задачка от Dolzenko. Легко решается на эрланге, но плохо на Clojure. Можете потренироваться :)

А не создать ли ru_clojure? (via alexott , astoon & san_a ).. и Х днями позже san_a создает его :)

Пример ленивых коллекций на Clojure от invis87

Функциональные комбинаторы fn/and, fn/or и fn/not by zahardzhan.

Похоже эра функциональных языков пошла) Куда ни глянь, везде #clojure,#scala,#f#,#haskell,#lisp... Почему только сейчас ? (ура, товарищи, значит все наши усилия не напрасны!)

А в это время в рунете про Clojure (24 января -> 05 февраля 2010)

Fri, 05 Feb 2010 17:01:20 +0000

ivan_gandhi спрашивает "В чём цимес-то? В том, что это лисп на jvm? С таким же успехом можно форт поставить. Я что хочу сказать - разве техника не ушла уже вперёд? Меня всё подташнивало, пока я читал эту книжечку - как окунулся в атмосферу 20-летней давности, когда торжественно открывались новые способы хитрым образом устроить то, что на самом деле можно одной строчкой выразительно написать на, извините, Хаскеле."

Deepwalker в другом месте пишет "что так все с этим clojure носятся? Ну он же страшен, у него же скобок больше чем осмысленных символов. Я понимаю, TM там, но неужели в 21-ом веке нельзя синтаксис причесать?" .

Riffm: "ты видел код на clojure? я один раз посмотрел, больше не хочу"

У кого что есть добавить? Возразить? :)
Еще один холиварный топик: Zahardzhan утверждает, что "Clojure-комунити сделало за два года в разы больше, чем Common Lisp-комунити за двадцать лет". Он же советует хороший leiningen плагин для автодокументации clojure-проектов (via twitter). Примерно тоже самое говорит holmic: "Clojure движется вперед, как локомотив на полных парах. За 2 года он набрал коммунити и библиотек не меньше чем CL за 25".
Отличная подборка видео-материалов по Clojure от Alexott.
"скала гнетет, а кложура рулит"! Обсуждение на juick
"Лол, в библиотеке кложуры есть бесконечная последовательность простых чисел. Интересно, оно действительно кому-то надо, или она там потому-что это просто прикольно?" via juick
Clojure hello fibonacci, хвостовая рекурсия (by Владимир Долженко).
На lisper.ru открылся подфорум о Clojure (via zw0rk)
"Каково дебажить многопоточное приложение в питоне? В clojure в куда проще - в эмакс слиме есть инспектор всего подряд." (via zahardzhan)
Scala VS Clojure. Энглиш, если в кратце, то автор советует Scala :) (via cybem)
Alexott играется с clojure-hadoop. Ждем результатов :)
Задачка для разминки ума и тренировки в Clojure. Робот на бесконечной лестнице. (by Владимир Долженко)

clojure in action

Fri, 29 Jan 2010 10:07:24 +0000

Пишу статью по функциональному дизайну (точнее, как я это понимаю...:) ) с примерами на Clojure для вполне реальной задачи, с которой столкнулся на работе, которую раньше я бы решил с применением ООП техник. Накатал пока 3 страницы и задумался - выложить постом в ЖЖ как и планировал, организовать локальный Coding Dojo по этой проблеме и отточить решение, или выступить сначала с этой темой на девклабе?

3 HelloWorld на Clojure

Sat, 23 Jan 2010 23:47:17 +0000

Сначала написал об этом у astoon в комментариях, а потом решил и себе сохранить. Вдруг я соберусь перевести http://clojure.org/compilation и захочу добавить немного примеров? :)

Clojure файлы можно запускать как прямо с помощью Clojure скрипта (1), так и компилировать в .class файлы. Это можно делать с помощью двух способов: как используя command line (2), так и внутри скрипта Clojure/REPL (3).

Соответственно, варианты следующие:
1)
есть hello.clj где есть одна строка: (println "hello world").

C:\>java -cp c:\java\clojure-1.1.0\clojure.jar clojure.main c:\hw\hello.clj
-> hello, world!

2)
есть hello_main.clj, который выглядит так:

(ns hello_main
	(:gen-class))

(defn -main []
	(println "hello, world!"))


C:\>java -classpath c:\java\clojure-1.1.0\clojure.jar;c:\hw;c:\hw\classes 
-Dclojure.compile.path=c:\hw\classes clojure.lang.Compile hello_main
Compiling hello_main to c:\hw\classes

C:\>java -classpath c:\java\clojure-1.1.0\clojure.jar;c:\hw;c:\hw\classes hello_main
hello, world!

3)
Есть hello_compile.clj, который выглядит так:

(ns hello_compile
	(:gen-class))

(defn -main []
	(println "hello, world from hello_compile!"))


C:\>java -classpath c:\java\clojure-1.1.0\clojure.jar;c:\hw;c:\hw\classes clojure.main
Clojure 1.1.0
user=> (set! *compile-path* "c:/hw/classes")
"c:/hw/classes"
user=> (compile 'hello_compile)
hello_compile

C:\>java -classpath c:\java\clojure-1.1.0\clojure.jar;c:\hw;c:\hw\classes hello_compile
hello, world from hello_compile!

Кстати, встретился с двумя интересными неудобствами. Во первых - при компиляции нужно указывать не файл, а namespace. Если сделать так:

java -classpath c:\java\clojure-1.1.0\clojure.jar;c:\hw;c:\hw\classes 
-Dclojure.compile.path=c:\hw\classes clojure.lang.Compile c:\hw\hello_main

то получишь очень непонятный exception:

Compiling c:\hw\hello_main to c:\hw\classes
Exception in thread "main" java.io.FileNotFoundException: Could not locate c:\hw\hello_main__init.class 
or c:\hw\hello_main.clj on classpath:
        at clojure.lang.RT.load(RT.java:402)
        at clojure.lang.RT.load(RT.java:371)
        at clojure.core$load__6449$fn__6458.invoke(core.clj:4171)
        at clojure.core$load__6449.doInvoke(core.clj:4170)
        at clojure.lang.RestFn.invoke(RestFn.java:413)
        at clojure.core$load_one__6379.invoke(core.clj:4007)
        at clojure.core$compile__6464$fn__6466.invoke(core.clj:4181)
        at clojure.core$compile__6464.invoke(core.clj:4180)
        at clojure.lang.Var.invoke(Var.java:359)
        at clojure.lang.Compile.main(Compile.java:56)

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

c:\tools\jad>java -classpath c:\java\clojure-1.1.0\clojure.jar;c:\hw;c:\hw\classes 
-Dclojure.compile.path=c:\hw\classes clojure.lang.Compile hello-main
Compiling hello-main to c:\hw\classes
Exception in thread "main" java.lang.Exception: namespace 'hello-main' not found after loading '/hello_main'
        at clojure.core$load_one__6379.invoke(core.clj:4010)
        at clojure.core$compile__6464$fn__6466.invoke(core.clj:4181)
        at clojure.core$compile__6464.invoke(core.clj:4180)
        at clojure.lang.Var.invoke(Var.java:359)
        at clojure.lang.Compile.main(Compile.java:56)

Clojure в рунете (18 -> 23 января 2009)

Sat, 23 Jan 2010 13:12:01 +0000

Пример рабочей конфигурации Maven для компиляции исходников clojure в jar. (здесь, via alexott)

Почему Clojure набирает популярность, в то время когда про другие Lisp-ы не слышно? (здесь, @andreypopp) @_semenov_ считает, что ФП просто модно в Java мире, а andreypopp предполагает, что пользователи Clojure в основном не-java программисты и причина в другом.

Clojure in Action за 10$ с купоном dotd0121. (здесь, via alexott)

Постепенно становится все больше и больше восторженных комментариев java (и не только) программистов в адрес Clojure. (здесь, здесь, здесь, здесь, здесь)

Вакансия в Москве. Разработчик на Clojure (здесь, via dulanov)

Clojure in Action for 10$

Fri, 22 Jan 2010 09:54:12 +0000

Кстати, сейчас есть еще одна MEAP книга по Clojure: Clojure in Action. С купоном dotd0121 всего 10$. Темы, которые там раскрываются: clojure itself; real-world application; web-scale systems design; DSLs. ух! :)

clojure epic fail

Sat, 16 Jan 2010 21:54:59 +0000

Как мы выяснили с anton_arhipov : Clojure, в отличии от Groovy, стоит аккуратно использовать для работы с плавающей точкой.

Groovy выглядит так:
0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 = 1

0.1 в груви это BigDecimal, поэтому создается 10 объектов, складываются и получается еще один со значением 1.

В Clojure ситуация плачевная.
(+ 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1) возвращает 0.9999999999999999.
В принципе, можно решить проблему, если использовать не double, а вариант с BigDecimal тоже. Или использовать рациональные числа:
(+ 0.1M 0.1M 0.1M 0.1M 0.1M 0.1M 0.1M 0.1M 0.1M 0.1M) = 1M
и
(+ 1/10 1/10 1/10 1/10 1/10 1/10 1/10 1/10 1/10 1/10) = 1

Но, как правильно возразили - в базе хранят в виде 0.1, поэтому нужно все равно что-то делать. Например, конвертировать 0.1 в BigDecimal или Ratio:
(bigdec 0.1) = 0.1M
и
(rationalize 0.1) = 1/10

Все бы было хорошо, но предположим в базе хранят цены, а функция хочет увеличить цену на 10%. Clojure, как очень гибкий язык, вполне может использоваться не-специалистами, которые обязательно напишут:
(* 100M 1.1)

Лично я ожидал увидеть здесь конвертацию 0.1 в BigDecimal, но ни тут то было:
(* 100M 1.1) = 110.00000000000001
(class (* 100M 1.1)) = java.lang.Double

К слову, Scala тоже не конвертирует 0.1 в BigDecimal, но по крайней мере у нее с арифметикой все ок:

scala.BigDecimal(1.5) * 1.5
res9: BigDecimal = 2.25

Вот такая вот фигня.

Clojure ratio

Sat, 16 Jan 2010 20:30:18 +0000

Где-то на просторах твиттернета пробегал вопрос "А почему Clojure лучше, чем Scala или Groovy?". В Clojure можно так:
user=> (+ 3/4 1/6)
11/12

Groovy, Scala и прочие - так не умеют :)

DSLs in Action

Thu, 14 Jan 2010 21:24:31 +0000

Ох-эх-ух! Где бы найти все время чтобы все это прочитать!

FUD Scala vs Clojure!

Thu, 14 Jan 2010 21:06:56 +0000

Вот для примера два варианта программы, которые делают одно и то же:

Вариант на Scala

type Supercalifragilisticexpialidocious = java.lang.Integer

implicit def Supercalifragilisticexpialidocious2Int(tehThingToConvert:Supercalifragilisticexpialidocious) = {
  tehThingToConvert.asInstanceOf[Int]
}

trait ClosureTestMixin {
  def makeAdder(tehAdditionValue:Supercalifragilisticexpialidocious):Function1[Int,Int]
}

class AdderMaker extends ClosureTestMixin {
  def apply(tehAdditionValue:Supercalifragilisticexpialidocious):Function1[Int,Int] = {
    new Function1[Int,Int] {
      def apply(tehOtherAdditionValue:Int):Int = {
        return tehAdditionValue.$plus(tehOtherAdditionValue.asInstanceOf[Supercalifragilisticexpialidocious])
      }
    }
  }

  def makeAdder(tehAdditionValue:Supercalifragilisticexpialidocious):Function1[Int,Int] = {
    return this.apply(tehAdditionValue)
  }
}

val tehAdderMakerInstance = new AdderMaker()

val tehAdderPlus10 = tehAdderMakerInstance.makeAdder(10)

tehAdderPlus10.apply(9)
//=> 19

Вариант на Clojure

(((fn mk-adder [x] #(+ % x)) 10) 9)

Разница очевидна! 29 строк и почти тысяча символов на Scala и всего 35 символов на Clojure!

p.s. если есть идеи, как сделать вариант со Scala больше, длиннее и страшнее - не стесняйтесь, говорите. Или напишите fogus-у в комменты ;)

by fogus

кинул бы в твиттер, но вышел за пределы :)

Tue, 12 Jan 2010 21:35:36 +0000

Тыкаюсь с clojure. Настроение идет по синусоиде. После scheme кажется, что связали одну руку. И рекурсия не настоящая, и дебажить как непонятно и еще в книжках везде понапихивали println в функции. Правда возможности со списками радуют, да и я еще до тредов не добрался, там обещает быть веселее :)

Мысли вслух. Как рассматривать Clojure в контексте хотя бы лет 5?

Sun, 10 Jan 2010 16:21:15 +0000

Clojure придется постараться, чтобы захватить этот мир :) Нет, это очень классный язык и все такое. Больше того - он местами прагматичный и не пытается переделать все сразу. Проблема в том, что для эффективного использования Clojure - все равно нужно уметь программировать на Java. Для использования преимуществ функционального подхода - все равно прийдется в некоторой мере владеть императивным стилем. Плюс еще небольшая, но смесь синтаксисов для упрощения взаимодействия с Java аля:

(.. obj getController getAuthenticator authorize)
vs
(authorize (authenticator (controller obj)))

Clojure пошел по пути "что не сломано в Java, то и не чиним" (в отличии от groovy? По ощущениям там обернуто в собственные классы больше классов). В результате - стабильное, быстрое, production-ready ядро и хорошее взаимодействие с Java. Clojure классная вещь и настоящие джавамены оценят ее. Но я не понимаю, как позиционировать ее перед теми, кто еще только начинает программировать? С одной стороны, может это быть тем самым, откуда стоит начинать знакомство с платформой, постепенно переходя к Java? Или, наоборот, может стоит рассматривать Clojure лишь как еще одну Java библиотеку? Или же, как просто мостик в функциональное программирование?

требуется Clojure Middle back-end developer в Москву

andrey_promo — Thu, 17 Oct 2013 10:01:11 +0000

В наш проект https://www.getshopapp.com требуется Clojure Middle back-end developer.

Обязательно

Системное мышление

Умение писать параллельный код

Уверенное понимание концепций RDBMS

Опыт командой работы

Технологии

Clojure (уверенное знание)

MySQL (уверенно знание)

Java (желательно)

Python (желательно)

Git (+ Git Flow)

Apache/JBoss

JSON/XML

Желательно

Опыт разработки высоконагруженных сервисов

Опыт оптимизации/тюнинга JVM

Опыт оптимизации запросов к БД

Опыт работы с AWS

С нас:

Зарплата от 80 до 110 тысяч рублей (по результатам собеседования)

Офис в бизнес-центре в пределах 5ти минут от метро Автозаводская

Сильная команда, в которой можно быстро расти

Интересные задачи

Бонусы

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

Присылайте резюме на почту andrey(собачка)getshopapp.com

Вакансия: Новосибирск, Java/Scala/Clojure-разработчик (платформа Eclipse), в офис, 110 000 р.

varg242 — Thu, 31 May 2012 10:18:41 +0000

Одной хорошей компании (не российской) в офис в Новосибирск требуются Java/Scala/Clojure-разработчики, знающие и любящие платформу Eclipse. Кандидаты из других городов/стран горячо приветствуются.

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

Нам не важно, знаете ли вы Java, С#, и т.д. Дело в том, что скорее всего вы не знаете Fantom, а на нем вам тоже, возможно, придется программировать. Кроме того, если вы знакомы со Scala или Clojure на достойном уровне - мы готовы с вами работать минуя всякие собеседования.

Название компании - в личку.

Резюме присылайте на russianvarg@gmail.com.

j2me и ClassLoader в clojure

Mike Potanin — Thu, 13 Jan 2011 08:10:13 +0000

Кто-нибудь скрещивал clojure и j2me?
У меня при попытке скомпилировать переписанный на clojure просой пример программы для j2me возникает ошибка:

Caused by: java.lang.UnsatisfiedLinkError: javax.microedition.lcdui.DeviceCaps.init()V
	at javax.microedition.lcdui.DeviceCaps.init(Native Method)
	at javax.microedition.lcdui.DeviceCaps.<init>(Display.java:3223)
	at javax.microedition.lcdui.Display.<clinit>(Display.java:489)
	at java.lang.Class.forName0(Native Method)
	at java.lang.Class.forName(Class.java:247)
	at clojure.lang.RT.classForName(RT.java:1566)

Несмотря на то, что к классу javax.microedition.lcdui.Display обращение идет только из defn, компилятор пытается вызывать какие-то его методы, которые приводят к вызову нативного метода javax.microedition.lcdui.DeviceCaps.init. Даже загрузка нужной библиотеки командой

(System/load "/opt/sun-j2me-bin-2.5.2.01/bin/libzayit.so")

не помогает.
Можно ли побороть загрузку классов от j2me?

seq в vector

Mike Potanin — Fri, 10 Sep 2010 15:30:28 +0000

Можно ли преобразовать seq в vector (или что-нибудь с чем работает assoc) дешевле, чем apply vector?
Или аналог map, который бы порождал vector, если его применяют к весторам?

Конструкции вида (apply vector (map (partial apply vector) c) меня несколько пугают, а как без них нормально работать с векторами я не понимаю...

letrec

Mike Potanin — Wed, 25 Aug 2010 16:13:29 +0000

Есть ли макрос, аналогичный letrec их scheme или аналог declare, но работающий внутри let?
Через def рекурсивное определение работает нормально:

(declare z)
(def x (cons 1 (lazy-seq (map + x z))))
(def z (cons 1 x))

А через let не компилируется: (let [a (cons 1 (lazy-seq (map + a (cons 0 a))))] (take 17 a))

Волшебство и Магия Clojure

Я :-) — Mon, 28 Jun 2010 05:28:15 +0000

clojure conference

dream.designer — Fri, 14 May 2010 18:31:58 +0000

Так как на jabber.ru существуют lisp-, ocaml-, haskell-, erlang-конференции, решил создать оную и по clojure.

Добро пожаловать на clojure@conference.jabber.ru.

UPD: по такому случаю любителями IRC также был создан #clojure-ru на freenode.

lafy: Clojure video [devclub.eu #04-10]

Fri, 07 May 2010 09:01:42 +0000

Не могу пройти мимо видео, сделанное Евгением Холодковым

lafy: Clojure video [devclub.eu #04-10]

слайды здесь http://www.planvita.com/devclub/clojure-devclub-30-04-2010.pdf

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

mock и stub в clojure

edbond — Mon, 22 Mar 2010 11:32:51 +0000

Подскажите как создавать mock'и в clojure?
Интересует нечто вроде fakeweb http://fakeweb.rubyforge.org/

Google Trends: clojure

Mon, 15 Mar 2010 07:26:31 +0000

Кто-нибудь может объяснить - почему clojure по регионам (Russian Federation) на втором месте, а по языкам на четвертом? Как они там считают?

Google Trends: clojure

Да, кстати, никого не удивляет несколько повышенный интерес России (как региона) к clojure? Кто все эти люди?

ru_clojure @ 2010-03-09T13:44:00

Tue, 09 Mar 2010 11:44:53 +0000

clojure по-русски

Замечательная статья alex-ott (http://fprog.ru/2010/issue4/alex-ott-clojure/) сподвигла на создание данного сообщества.
Надеюсь на просторах русского инета найдется несколько человек, заинтересованных в освоении и практическом применении очень перспективного и нового языка clojure.

Лично мне clojure интересен в контексте создания DSL и интеграции с JVM. Признаюсь честно, что в ФП практически не имею опыта, но надеюсь что данное сообщество поможет привлечет в мир функционального программирования не только меня :)

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

ЗЫ. Хочу быть просто читателем этого сообщества. С радостью уступлю место "смотрителя" любому желающему.

Clojure - пишем программу с базовым интерфейсом и собираем ее в .jar

Crazy_Owl — Thu, 09 Dec 2010 19:46:00 +0000

Переписал пример из "Core Java. Fundamentals" на clojure, чтобы разобраться с тем, как на ней пишется GUI.

Код и комментарии - под катом.

Вот код:

(ns interfacetest.core
  (:import [javax.swing
            JFrame
            JLabel
            JFileChooser
            JMenuBar
            JMenuItem
            JMenu
            ImageIcon]
           [java.io
            File]
           [java.awt.event 
            ActionListener])
  (:gen-class))

(defn create-listener [lmbd]
  (proxy [ActionListener]
      []
    (actionPerformed [e] (lmbd e))))

(defn initframe [#^JFrame frame]
  (let [lbl (JLabel.)
        chooser (JFileChooser.)
        menubar (JMenuBar.)
        menu (JMenu. "File")
        openItem (JMenuItem. "Open")
        exitItem (JMenuItem. "Exit")]
    (doto openItem
      (.addActionListener
       (create-listener
        (fn [e] (let [result (.showOpenDialog chooser nil)
                      getname (fn [] (.. chooser getSelectedFile getPath))]
                  (if (= result JFileChooser/APPROVE_OPTION)
                      (.setIcon lbl (ImageIcon. (getname)))))))))
    (doto exitItem
      (.addActionListener
       (create-listener
        (fn [e] (System/exit 0)))))
    (.setCurrentDirectory chooser (File. "."))
    (doto menu
      (.add openItem)
      (.add exitItem))
    (.add menubar menu)
    (doto frame
      (.setDefaultCloseOperation JFrame/EXIT_ON_CLOSE)
      (.setSize 300 300)
      (.setVisible true)
      (.add lbl)
      (.setJMenuBar menubar))))


(defn -main []
  (let [fr (JFrame. "Hello world")]
    (initframe fr)))

Результатом работы программы будет небольшая формочка с двумя пунктами меню - "Open" и "Exit". Open предложит выбрать изображение, которое и будет помещено на формочку (изображение не ресайзится, от очень большой картинки будет показана только часть.

Разберем код по порядку.

Инструкция (ns) задает пространство имен под названием interfacetest.core. В ней же указано, что необходимо сгенерировать Java-класс для этого пространства имен (что и будет сделано при компиляции) - :gen-class. В директиве :import подключаются классы из стандартной библиотеки Java (написанные не на Clojure).

Функция create-listener превращает функцию clojure в объект, реализующий интерфейс ActionListener. Эти объекты понадобятся нам позже, для меню.

Далее следует функция initframe, принимающая объект класса JFrame (инструкция #^JFrame заставляет делать проверку типов при компиляции, если я ничего не путаю). В let-биндинге создаются объекты JMenuBar, JFileChooser, JMenuItem и так далее, а затем, при помощи инструкций doto производятся действия над этими объектами и собирается интерфейс.

(doto object ...)

позволяет производить несколько действий подряд над одним и тем же объектом. Обычно вызов методов объектов производится так:

(.method object args)

, в случае с doto можно делать так:

(doto object (.method args) ... )

, чем мы и пользуемся.

Затем определяется метод -main, который будет вызываться java'ой. В нем мы создаем фрейм и вызываем для него initframe.

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

Вроде все. Теперь про компиляцию.

Пространство имен называется interfacetest.core, значит, создаем на диске директорию interfacetest и кладем туда файл core.clj с указанным выше содержимым. Затем переходим в командной строке в директорию уровнем выше interfacetest, и запускаем REPL Clojure. В интерпретаторе пишем:

(compile 'interfacetest.core)

Файл откомпилирован, и на диске создана директория classes, в которой лежат interfacetest/*.class. Проверить, что все получилось, можно следующим образом - из командной строки переходим в директорию classes (желательно положить туда же clojure.jar) и пишем:

java -cp .;clojure.jar interfacetest.core

Обратите внимание - здесь указана версия для Windows - разделитель ";" в classpath. Для линукса нужно будет заменить ";" на ":".

Осталось только собрать наш jar. Распаковываем clojure.jar как обычный .zip-архив, копируем директорию clojure (ту, которая лежит в директории распаковки), кладем ее рядом с interfacetest и пишем:

jar cvfe jarfilename.jar interfacetest.core clojure\* interfacetest\*

Опять же, это версия для Windows - для линукса заменяем обратные слеши на прямые. Получаем исполняемый файл, который запускается без лишних библиотек.

Вроде все. За кадром остался вопрос, как определить только используемые классы из clojure.jar и не включать из в итоговый jar, тем самым уменьшая его размер (думаю, это можно сделать).

Clojure-вакансия

Dmitry — Thu, 20 Jun 2013 11:34:00 +0000

Друзья, нам на проект нужен Сlojure-программист. Мы делаем американскую копию сайта youdo.ru. Часть исходника я уже написал, но мне подкинули еще один проект параллельно, и теперь мне нужен помошник.

Используемые технологии: Clojure в бэкенде, ClojureScript на фронтенде. Архитектура в стиле Single-Page Application. Интеграция с Google+, Facebook, Google Maps и платежными системами.

Варианты сотрудничества обсуждаемые, но очень желательно, чтобы хотя бы полдня вы были в офисе.

Если кого заинтересовал -- пишите d.bushenko@gmail.com

Курсы по Clojure закончились

Dmitry — Thu, 02 May 2013 11:58:00 +0000

В марте я начал курсы по языку Clojure. Все участники были поделены на три группы: А -- очники, B -- дистанционщики с преподавателем, С -- дистанционщики без преподавателя. Из примерно сотни стартовавших до конца обучения дошли всего 18 человек.

На фото -- мы с Никитой Белоглазовым толкаем речь.

Поскольку слушателей курсов было много, я попросил помочь мне вести группы Никиту Белоглазова, Алекса Отта, Никиту Прокопова и Виталия Монастырева. Благодаря их помощи, курсы получились довольно масштабными, если бы я был один, то смог бы взять максимум человек 30.

Параллельно я провел три занятия по Clojure и функциональному программированию в БГУ у третьекурсников ФПМ. Двум студентам, выполнившим ДЗ, я тоже вручил сертификаты.

На фото я вручаю сертификат, а Никита награждает значком с символом Сlojure

На курсах мы разобрали следующие основные темы:

1. Основы ФП

2. Параллельное программирование

3. Макросы и предметно-ориентированные языки

4. Веб-разработка

По итогам курсов те, кто дошли до конца, разработали свое небольшое веб-приложение в стиле Single-Page Application. Самое забавное, на мой взгляд, сделал Виталий Монастырев (http://www.komoku.org:3000/index.html).

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

1. Разработаем сайт минского коммьюнити clojure.by

2. Задачи комьюнити:
а) пропаганда clojure, культурная экспансия в умы ООП-инфицированных;
б) обзоры интересных clojure-технологий в виде докладов на митапах;

в) совместная разработка best practices по использованию clojure в различных областях. На данный момент следующие темы требуют выработки общих best practices: веб-разработка, разработка параллельных алгоритмов средствами clojure, разработка предметно-ориентированных языков.

г) организация clojure-хакатонов.

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

3. Создать чисто технарьскую конференцию thestrangeloop.by по примеру thestrangeloop.com. С этим пунктом пока много неясного, предлагаю его обсудить. Но в целом, на этой конфе должны быть исключительно программерские доклады от классных докладчиков (возможно даже дистанционно). Языки и технологии в основном маргинальные, вроде Clojure, Haskell, CL, Scheme, Emaсs Lisp, Scala, ML, Erlang и т.д. Задачи конфы -- дать возможность обсудить проблемы использования маргинальных технологий "вживую", познакомиться с грамотными специалистами. Причем я думаю, тезисы докладов стоит публиковать заранее, чтобы слушатели ознакомились и могли заготовить вопросы для обсуждения. Возможно даже такую конфу стоило бы проводить в онлайне -- дешево и сердито.

По поводу сlojure.by и thestrangeloop.by прошу высказаться всех заинтересованных.

Настройка окружения Clojure и IntelliJ IDEA на MS Windows

Dmitry — Sun, 14 Apr 2013 18:02:00 +0000

Во-первых, необходимо установить leiningen2. Заходим на leiningen.org, читаем инструкции.

Качаем lein.bat куда-нибудь, например, в q:\programs\lein. Затем необходимо прописать этот путь в переменную %PATH% таким образом, чтобы lein.bat был доступен отовсюду.

Откройте cmd.exe и выполните команду lein self-install. Leiningen скачает и самостоятельно установит свою последнюю версию.

Домашний каталог утилиты lein -- C:\users\<user>\.lein, где <user> -- имя вашего пользователя. В домашнем каталоге lein находятся файлы настройки. Создайте там файл profiles.clj с таким содержимым:

{:user {:plugins [[lein-pprint "1.1.1"]
                  [lein2-eclipse "2.0.0"]
                  [lein-idea "1.0.1"]]
        :dependencies [[slamhound "1.3.1"]]}}

Здесь перечислино несколько плагинов для интеграции с IDE Eclipse и IntelliJ IDEA.

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

Чтобы создать новый проект, выполните команду lein new myclojure1, где myclojure1 -- имя нового проекта.

Зайдите в каталог myclojure1 и выполните там команду lein deps. Leiningen подятянет все зависимости (в том числе и саму Clojure).

Сконвертируйте полученный проект в IDEA-project командой lein idea.

Далее, необходимо импортировать этот проект в IntelliJ IDEA. Чтобы IDEA могла работать с Clojure -- установите плагин LaClojure. Затем импортните проект myclojure1 (не забудьте настроить JDK для этого проеката, если не настроили для всей IDEA).

Запустить REPL можно выбрав пункт меню Tool -> Start Clojure Console.

Скомпилировать исходник на Clojure можно выбрав его в дереве проекта (src\myclojure1\core.clj), и выбрав пункт меню Tools -> Clojure REPL -> Load file in REPL.

Для того, чтобы перейти в неймспейс этого файла, обратите внимание на первую строчку core.clj:

(ns myclojure1.core)

Введите в REPL следующий текст:

(in-ns 'myclojure1.core)

После выполнения этой команды, все определения, доступные в core.clj станут доступны и в REPL.

Успехов!

Как деплоить Clojure на OpenShift

Dmitry — Thu, 04 Apr 2013 14:42:00 +0000

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

1. Генерим открытый ssh-ключ:

$ ssh-keygen -t rsa

В каталоге .ssh вы получите два файла: id_rsa и id_rsa.pub.

2. Зайдите в настройки своего аккаунта.

3. Выберите «Change settings», попадете на экран Personal Information.

4. Нажмите кнопку «Add a new key...», попадете на экран Add a public key. Скопируйте туда содержимое файла id_rsa.pub.

Далее необходимо создать приложение.

5. Выберите вкладку «My Applications» и нажмите кнопку «Add application». OpenShift покажет вам экран выбора типа приложения. Выберите приложение Tomcat7.

6. На экране конфигурации нового приложения введите его имя и нажмите кнопку «Create application.

7. Откроется экран с подробностями о созданном приложении. Нажмите на ссылку «Add cartridge».

8. В открывшемся экране выберите нужную вам базу данных. В этом примере мы рассматриваем MySQL 5.1. Добавьте этот картридж.

9. OpenShift покажет вам экран с информацией о вашей БД. Важный момент: хост и порт для коннекта из приложения хранятся в переменных окружения среды OPENSHIFT_MYSQL_DB_HOST и OPENSHIFT_MYSQL_DB_PORT.

10. Зайдите на вкладку My applications, выберите ваше приложение и нажмите на ссылку «Want to login to your application?». OpenShift покажет вам ssh-команду для логина на сервер.

11. Введите показанную команду

$ ssh 515c...00401@helloworld-writing.rhcloud.com

Если до этого вы правильно зарегистрировали ваш id_rsa.pub, то ssh тихо залогинит вас на сервер и не спросит пароля.

Выполните команду

$ ctl_all restart

Эта команда необходима для того, чтобы OpenShift рестартанул приложение и подтянул картридж с MySQL. После перезагрузки в окружении среды перезапущенного Tomcat появятся переменные OPENSHIFT_MYSQL_DB_HOST и OPENSHIFT_MYSQL_DB_PORT.

12. Выйдите из ssh-сессии командой exit. Сконфигурируйте строку соединения к MySQL следующим образом.

(def env (into {} (System/getenv)))

(def dbhost (get env "OPENSHIFT_MYSQL_DB_HOST"))

(def dbport (get env "OPENSHIFT_MYSQL_DB_PORT"))

(def default-conn {:classname "com.mysql.jdbc.Driver"

:subprotocol "mysql"

:user "myuser"

:password "mypassword"

:subname (str "//" dbhost ":" dbport "/helloworld?useUnicode=true&characterEncoding=utf8")

:delimiters "`"})

В поля :user и :password необходимо подставить значения, которые OpenShift выдал вам на шаге 9. В поле :subname слово helloworld — это имя БД (также получено на шаге 9).

13. Соберите ваше веб-приложение командой lein ring uberwar. Переименуйте её в ROOT.war.

14. Скопируйте war-ку на сервер:

$ scp ROOT.war 515....01@helloworld-writing.rhcloud.com:app-root/data

15. Залогиньтесь на сервер

$ ssh 515...401@helloworld-writing.rhcloud.com

16. Переместите скопированную war-ку в каталог с веб-приложениями:

$ mv app-root/data/ROOT.war app-root/runtime/repo/webapps/

17. Через некоторое время ваше новое приложение будет доступно. В моем случае — по адресу http://helloworld-writing.rhcloud.com.

Clojure в БГУ

Dmitry — Wed, 27 Mar 2013 17:57:00 +0000

Сегодня договорились с деканом ФПМ БГУ о том, что я проведу три занятия по Clojure на ФПМ (занятия парные, лекция + ПЗ) в рамках спецкурса по функциональному программированию.

Главная печаль в том, что до крайности не хочется заниматься настройкой окружения в лаборатории, т.к. у них там компы c Windows XP и дохлым интернетом. Вот как студентам установить lein?

Одно из решений, которое я придумал: предложу студентам залогиниться на мой ноутбук по SSH и работать там в консольном Emacs-е. Заодно и ктулхуугодный редактор пропиарю :-)

Почему Emacs?

Dmitry — Sun, 10 Mar 2013 01:19:00 +0000

На сегодняшний день основным инструментом программистов являются супер-технологичные IDE, помогающие выполнять процентов 80 ежедневной работы. Они умеют очень многое: автоматически дополнять код, отлаживать приложение, проводить сложный рефакторинг. Поэтому люди, пользующиеся такими старыми, с виду, инструментами, как Emacs, кажутся совсем уж чудаками. Но чудачество ли это в самом деле? И почему этот текстовый редактор до сих пор жив и все еще пользуется уважением?

На моей предыдущей работе я программировал в основном J2EE-приложения. Мне очень нравились Eclipse и Jetbrains Idea, с их помощью мне удавалось за очень короткое время разрабатывать формочки, веб-сервисы и даже архитектуру приложения. Да я, в общем, не особо и задумывался о том, на чем писать. Все пишут в Eclipse -- ну и я тоже.

А потом все резко изменилось. Мне предложили написать для платформы Android виртуальное казино. В приложении была всего одна формочка, зато масса логики, которую нужно было алгоритмизировать. Самым неприятным занятием было объявить в xml-файле 130 полей разметки на столе для ставок, затем их же проинициализировать в коде на java. Ни Eclipse, ни Idea уже ничем не могли мне в этом помочь, а выполнять эту работу вручную совсем не хотелось. Мои коллеги относились к этому проще. Они полагали, что раз платят, то нужно выполнять задание, даже если оно такое бездумное и скучное. Также полагал и мой менеджер. А как считаете вы?

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

Чем же сегодня занимаются программисты на крупных фирмах, особенно на тех, которые практикуют "промышленное программирование"? Разве программированием? Большая часть времени уходит на всякую конфигурацию Spring или других фреймворков, генерацию заготовок кода при помощи IDE, добавление всяческих аннотаций для связи различных частей кода, написание и прогон тестов и т.д. Изредка код писать все-таки приходится. Но это, как правило, очень простой код: взять что-то из базы, привести объект к другому типу, в цикле пройтись по коллекции. Давайте спросим себя: неужели именно такое программирование нам нравится?

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

Первое, что я обнаружил, так это то, что текстовый редактор в Eclipse никуда не годится. Я набираю код всеми десятью пальцами сразу, и мне не надо смотреть на клавиатуру, когда мои пальцы находятся над клавишами алфавита. А для перемещения по тексту необходимо сдвигать правую руку на клавиши со стрелочками или даже еще дальше -- к PgDown/PgUp. Но даже это не идет ни в какое сравнение с тем, как отвлекает необходимость хвататься за мышку! Это здорово выбивает из состояния потока!

Во-вторых, конечно же, я не стал писать эти 130 полей вручную. Нужно было разработать какой-то генератор кода, и здесь Eclipse опять ничем не смог мне помочь. Писать плагины для Eclipse невероятно затратное дело. Следовало выбрать один из скриптовых языков вроде Perl, Python или Ruby. Но я все равно не понимал, почему не сделать возможность в Eclipse для написания простых плагинов как раз для таких случаев. В редакторе Eclipse есть курсор, и им можно было бы выделять фрагменты текста для обработки. А когда пишешь скрипт для обработки текста, например, на Perl, курсора нет, и необходимо как-то парсить структуру текста регулярными выражениями или помечать места для упрощения анализа текста.

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

Мне не понравилось программировать казино на Android в Eclipse. Оказалось, что Eclipse прекрасно подходит для задач code monkeys, ежедневно клепающих формочки для очередной CRM на Java. Но этот же Eclipse совсем плохо показывает себя в задачах, для которых у него нет заготовок вроде генераторов кода.

Давайте спросим себя, что же это за задачи, для которых IDE подходят не очень хорошо?

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

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

А вы знаете, что, например, в Emacs можно настроить сочетания клавиш таким образом, чтобы всю работу с текстом, в том числе и перемещение, можно было выполнять, не убирая пальцы с алфавитно-цифровой клавиатуры? И тем более не хватаясь за мышку? Когда концентрация на коде максимальна, очень важно не отвлекаться на посторонние вещи!

Редактору Emacs легко придать абсолютно аскетичный вид. Казалось бы, зачем убирать панели инструментов, строку меню, боковые навигаторы кода и прочие элементы управления, если у нас итак достаточно вместительные экраны мониторов? Ответ очень простой: пространства на экране никогда не бывает достаточно! Когда-нибудь в будущем, когда картинка будет проецироваться пользователю напрямую в мозг и не будет ограничена размерами монитора, все равно будут те, кому и такое изображение покажется недостаточно вместительным. Эти будущие гики, также, как и сегодняшние, будут стараться убрать с изображения все отвлекающие детали и максимально освободить себе рабочее пространство, чтобы заполнить его действительно полезной информацией.

Таким образом, Emacs идеально подходит для тех, кому требуется полная концентрация внимания на редактируемом тексте.

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

Я специально хочу остановиться на этой мысли: писать плагины для Emacs так просто, что я, не задумываясь, пишу их чуть ли не для каждой сложной задачи. Посмотрите, как выглядит "Hello World" в стиле Emacs Lisp:

(defun my-test-message ()
(interactive)
(message "Hello, World!"))

Обратите внимание, сколько xml-конфигураций мы здесь не правим, сколько интерфейсов не реализовываем, сколько классов не наследуем! Всего одна простая функция, и если её скомпилировать (C-x C-e за последней скобкой функции), она тут же становится частью редактора Emacs!

Именно эта простота написания плагинов так сильно подкупает в Emacs. Когда я программирую на Java, я пишу расширения Emacs для генерации всего того boilerplate-кода, который не умеет генерировать Eclipse. Emacs автоматизирует мне много по-настоящему скучной рутинной работы!

Есть и еще одна проблема, с которой плохо справляются IDE -- это нестандартные и предметно-ориентированные языки программирования. Для них нет и никогда не будет поддержки в Eclipse, Idea, Netbeans и т.д. Но зато вы с лёгкостью можете добавить поддержку любого нужного вам языка в Emacs!

У Emacs есть еще один существенный плюс: превосходная интеграция с Clojure. Исторически сложилось так, что программисты на Lisp-подобных языках предпочитают разрабатывать программы в Emacs, потому что в этом редакторе есть все, что нужно лисперу. Это и правильная подсветка кода и скобочек, и автодополнение кода, и REPL для интерактивной разработки, и просмотр документации, и многое другое. Если вы планируете посвятить много времени Lisp-подобным языкам, то вам однозначно стоит попробовать Emacs. Тем более, что освоив Clojure вам будет уже довольно просто разобраться с Emacs Lisp и разрабатывать плагины для этого текстового редактора. Если у вас действительно возникнет желание изучить также и Emacs Lisp, могу порекомендовать вам пособие.

Откровенно говоря, нужно признать, что у Emacs есть одна проблема: довольно высокий порог вхождения. Далеко не с первого раза можно понять, как там что устроено и почему именно так, а еще как переделать, чтобы было удобнее. В Emacs множество комбинаций клавиш начинаются с Ctrl, от чего сильно устает левый мизинец; комбинации для перемещения курсора придумали как будто специально, чтобы ими было неудобно пользоваться: Ctrl-f, Ctrl-b, Ctrl-n, Ctrl-p. Это связано с тем, что Emacs создали очень давно, когда у клавиатур не только не было клавиши "Win", но даже и само расположение клавиш было другим. Например, Клавиша Ctrl находилась на том месте, где сейчас традиционно расположена Alt, и Ctrl в то время нажимали большим пальцем левой руки, а вовсе не мизинцем.

Но, как уже было сказано, ничто не мешает вам изменить управляющие клавиши. Например, известный Emacs-ер Xah Lee создал проект ergoemacs, в котором он предлагает совершенно иную раскладку, намного более эргономичную.

Для слушателей Clojure Course, которые хотели бы попробовать Emacs, я создал немного модифицированную версию Ergo Emacs. Этот конфиг, конечно, не заменит начального ознакомления с документацией, но зато поможет сделать работу с Emacs несколько удобнее.

Ниже несколько основных клавиатурных сочетаний, которые я использую в своем конфиге. Здесь используются следующие традиционные для Emacs обозначения клавиш: C -- Ctrl, M -- Alt, S -- Shift.

Перемещение курсора:

M-i -- up
M-k -- down
M-j -- left
M-l -- right
M-u -- word left
M-o -- word right
M-S-i -- page up
M-S-k -- page down
M-S-j -- beginning of document
M-S-l -- end of document
M-h -- end of line
M-S-h -- beginning of line
C-l -- go to line

Редактирование текста:

M-m -- new line
M-d -- backspace
M-f -- delete
M-Space -- start/end selection
M-c -- copy
M-x -- cut
M-v -- paste
M-s -- save document
C-o -- open file

Работа с окнами:

C-x 2 -- split window horizontally
C-x 3 -- split window vertically
C-x 0 -- close current window
C-x 1 -- leave only current window
M-q -- next window
M-S-9 -- shrink horizontal window
M-S-0 -- enlarge horizontal window
M-9 -- shrink vertical window
M-0 -- enlarge vertical window

Закладки:

C-b -- set bookmark
M-b -- jump to bookmark

Системные операции:

F5 -- run Emacs command
C-x C-c -- close Emacs
C-x b -- select buffer
C-x k -- kill buffer
C-c l -- truncate long lines on/off
C-g -- сancel
F11 -- show help for my keybindings

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

А вообще, конечно, очень рекомендую прочесть учебник по Emacs в переводе Алекса Отта.

14 марта стартуют курсы Clojure

Dmitry — Fri, 01 Mar 2013 13:26:00 +0000

Вам надоела многословность Java или C#? Вы хотите, чтобы писать программы было проще и быстрее? Вас достало писать вручную одни и те же паттерны проектирования?

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

С 14 марта по 18 апреля 2013г. в офисе компании ITA(г.Минск, проспект Независимости, 58) будут проходить курсы программирования на Clojure. Программа курсов включает в себя изучение основ функциональногои мета-программированиясредствами языка Clojure, а также применение Clojure для разработки современных веб-приложений.

Примерный план занятий:

14.03.2013 — Установка и настройка необходимых инструментов, введение в Clojure и функциональное программирование.

21.03.2013— Функции высшего порядка, ленивые вычисления, полиморфизм, STM, взаимодействие с Java.

28.03.2013 — Макросы, предметно-ориентированные языки, генерация кода.

04.04.2013— Введение в веб-стек Clojure. Ring, Compojure, lib-noir, развертывание приложений.

11.04.2013 — Генерация html (Clostache, Hiccup, Enlive), Взаимодействие с БД (Korma).

18.04.2013 — ClojureScript вместо JavaScript.

Для успешного прохождения курсов необходимо иметь представление о Java, SQL, HTML, CSS и JavaScript.

Количество мест на очную форму обучения ограничено. Поэтому те, кто хочет посетить курсы лично, должны будут выполнить тестовое задание на алгоритмизацию. Задание будет объявлено в группе «Clojure Course»в facebook 7 марта 2013г. Если у Вас есть желание получить задание предварительно, присылайте Ваши заявки на email: d.bushenko@gmail.com. После успешного прохождения очной формы курсов, слушатели получат сертификаты.

Для тех, кто не сможет попасть на очную форму обучения, мы предложим вам дистанционную. Информацию о том, как попасть на дистанционную форму обучения мы объявим в группе «Clojure Course» в facebook 7 марта 2013г.

Обзор Clojure на тусовке Software Craftmanship

Dmitry — Sun, 24 Feb 2013 21:50:00 +0000

На днях делал презентацию языка Clojure на тусовке Software Craftmanship.

Саму презентацию можно взять здесь. Видео доклада -- здесь.

Были разобраны следующие темы:
1. Какие причины заставляют программистов искать замену языкам промышленного программирования (Java, C#, C++, etc.).
2. Что такое Clojure.
3. Синтаксис Clojure.
4. Макросы -- самое мощное средство метапрограммирования.
5. Зачем нужны eDSL и как их пишут на Clojure.
6. Когда стоит, а когда не стоит применять Clojure.
7. Как продавать Clojure менеджеру и заказчику.
8. Как пользоваться Clojure, если от вас все-таки требуют код на языке промышленного уровня (например, Java).

Курсы Clojure -- продолжение

Dmitry — Mon, 28 Jan 2013 14:44:00 +0000

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

Скорее всего курсы начнутся через месяц, в последних числах февраля (это пока не точно). Еще мы планируем выдавать сертификаты о прохождении курсов тем, кто выполнит все домашние задания.

С помощью Алекса Отта я составил предварительную программу курсов. Опять же, это пока не официально, возможны изменения.

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

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

Всем, кто хочет и может помочь мне с материалами курсов, предлагаю выбрать тему/подтему или даже какой-то совсем уж ограниченный фрагмент занятия. Пожалуйста, связывайтесь по этому поводу со мной через email: d.bushenko-at-gmail.com Имена всех, кто будет помогать мне с материалами, тоже каким-нибудь образом увековечим.

Курсы Clojure онлайн

Dmitry — Fri, 25 Jan 2013 19:33:00 +0000

Мне удалось в какой-то мере заинтересовать руководство нашей фирмы языком Clojure. Если все будет хорошо, то в ближайшее время начну курс по Clojure для сотрудников. Лекции буду записывать и выкладывать по мере возможности.

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

Если есть желающие поучаствовать (либо помочь с подбором материала, либо пройти курс) -- пишите.

Web-разработка на Clojure

Dmitry — Sun, 06 Jan 2013 17:14:00 +0000

Как я уже писал в своей прошлой статье, мне удалось заинтересовать начальство разработкой на Clojure. Поскольку еще на предыдущей работе мне удалось выбить разрешение на использование Clojure в одном из проектов, можно сделать определенные выводы.

Легче всего убедить начальство в случае, если предстоит небольшой fixed-price проект, на который, предположительно, ресурсов выделено или впритык, или меньше, чем нужно. Ваш главный аргумент здесь – время (оно же – деньги). Вы берете предложенную вам оценку сроков и поясняете начальству, что вот на этом, этом и этом этапах (итерациях, модулях, системах и т.д.) можно сократить сроки разработки на 30-40%, если отказаться от Java в пользу Clojure. Любой умный начальник (ну а зачем вам работать у глупого?) как минимум выслушает ваше предложение о том, как сократить сроки.

Будьте готовы ответить на вопрос, за счет чего уменьшатся сроки. Это самый шаткий момент, здесь нужна максимальная предметность. Не стоит рассказывать о вредности мутабельного состояния или славном прошлом лиспа. Идеальный вариант – на примерах показать насколько меньше в Clojure различных церемоний, а также насколько проще в Clojure автоматизировать всю ручную работу, привычную Java-программистам.

В этот раз мне повезло сыграть на контрасте. Во-первых, я показал, насколько проще в Clojure работать с REST-сервисами, по сравнению с “правильным” способом на Java – библиотекой JAX-RS. Во-вторых, я немного рассказал о применении макросов для автоматизации, а также о том, насколько просто получить доступ к данным из БД (на примере библиотеки Korma).

Следующий вопрос, который необходимо будет решить – кто будет поддерживать ваш исходник, ведь Clojure кроме вас никто и не знает. Я предложил провести небольшой мастер-класс по Clojure, чтобы научить людей хотя бы читать и немного понимать Clojure-код. Главное здесь – избавить коллектив от страха перед скобочками. Кроме того, я раздумываю над тем, чтобы написать небольшую методичку, максимально приближенную к практике, о применении Clojure в web-разработке. Алекс Отт написал введение в сам язык (http://alexott.net/ru/clojure/clojure-intro/), но я думаю, есть смысл добавить описание популярных библиотек, а также рассказать о распространенных приемах разработки на Clojure.

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

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

Самое заметное изменение – смерть микро-фреймворка Noir. Как известно, Крис Гранжер собрал на Kistsarter-е нужную сумму для своего стартапа и сейчас во всю пилит экспериментальную супер-модерновую IDE LightTable. Поэтому на веб-фреймворк Noir и ORM Korma времени у него не осталось. Общими усилиями выпустили версию Noir 1.3, и на этом развитие фреймворка прекратилось.

К счастью, теперешний мейнтейнер Noir – Raynes (Энтони Гримс) – исхитрился разделить этот фреймворк на две части: сам Noir и библиотеку lib-noir. Так вот, библиотека lib-noir, которая содержит полюбившиеся всем “батарейки”, жива и развивается. Теперь её используют в связке с Compojure.

Энтони Гримс

Библиотеку Korma постигла более счастливая судьба. Пару недель назад в чате #clojure на irc.freenode.net Алекс Барановский предложил взять развитие Korma в свои руки. Ему дали права мейнтейнера, и теперь он по-стахановски постит в гитхаб коммит за коммитом. Пару дней назад Алекс опубликовал новую версию Korma – 13-ю бету, которая вышла вслед за 11-й спустя несколько месяцев.

Алекс Барановский

Compojure и Enlive ничем особенным не отметились за последние месяцы. Зато вышло несколько бет библиотеки Enfocus (ClojureScript-версии Enlive). Автор Enfocus Крейг Киркендалл полностью переработал архитектуру библиотеки. И теперь, в 1.0 версиях, в отличие от 0.9, для доступа к элементам DOM используется библиотека Domina. В целом, 1.0-версия Enfocus лучше и стабильнее 0.9 несмотря на значительные архитектурные изменения.

Крейг Киркендалл

Ну и пара слов о личных впечатлениях. Когда разрабатываешь Single-Page Application на Clojure, наиважнейшее значение приобретают unit-тесты. В jvm-версии Clojure все не так печально. Худо-бедно, стектрейс вам подскажет где и что отвалилось, хотя и здесь функциональное тестирование лишним не будет (статической типизации-то нету). Но в ClojureScript типизация настолько слабая, что на определенном этапе это может даже быть неудобным. Сизифов труд вам покажется лёгким и осмысленным по сравнению с рефакторингом работающего ClojureScript-приложения. Компилятор почти ни в чем вам не поможет, и основной способ докопаться до сути – как-то запустить засбоивший фрагмент, найти поломанную функцию и долго медитировать над её исходником.

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

Юнит-тесты на ClojureScript – это, пока что, пичалька. ClojureScript – инструмент молодой, развивающийся. На сегодняшнем этапе нет устоявшейся практики правильного написания юнит-тестов. Местами можно наткнуться на использование библиотеки PhantomJS. Но, признаюсь честно, мне не удалось найти толкового руководство по тому, как её завести. Да и у самого ничего не получилось. Поэтому, в моих проектах юнит-тесты ClojureScript достаточно кустарные.

Завершить обзор хотелось бы на приятной ноте. В 2012-м году вышли еще две очень классные книжки по Clojure.

Очень полезная и практическая книжка Clojure Programming. Помимо самого языка, в ней есть обзор основных популярных библиотек и практик разработки на Clojure.

И вторая, но единственная в своем роде, – ClojureScript: up and running. В ней всего 116 страницы, тянет на крупный туториал. Зато все по делу, без воды. Подробно рассказано, как завести ClojureScript и как разрабатывать на нем приложения.

Clojure пропаганда

Dmitry — Thu, 27 Dec 2012 23:00:00 +0000

Недавно предложил директору фирмы, где с недавних пор работаю, использовать Clojure для новых проектов. Не целиком, конечно, писать весь проект на Clojure (у нас на такой радикальный шаг еще не готовы). Но хотя бы часть функционала, например -- бизнес-логику.
А для того, чтобы убедить директора, что Clojure кое-в-чем лучше Java, я написал небольшой документ для сравнения плюсов и минусов от применения кложуры. Возможно, пригодится и вам.
Если есть идеи, что можно добавить или исправить, -- прошу в комменты.

Emacs Lisp Tutorial

Dmitry — Mon, 17 Sep 2012 11:33:00 +0000

Недавно один товарищ опубликовал учебник по Emacs Lisp-у. Неплохой, надо сказать, туториал, жаль что на английском. Что-то похожее мы написали с Алексом Оттом почти год назад. Наш учебник по Emacs Lisp-у можно найти здесь.

Swank Clojure заброшен, да здравствует nrepl.el!

Dmitry — Fri, 24 Aug 2012 13:14:00 +0000

На днях главный мейнтейнер swank-clojure Фил Хагельберг объявил о прекращении этого проекта. Вместо поддержки этого устаревшего проекта он объединяется с разработчиками nrepl.el.

Обычно такие новости не приносят ничего хорошего, т.к. нужно обновлять зависимости, пытаться запустить новую библиотеку, пройтись по полю с граблями. Но не в этот раз. Просто установив nrepl.el через пакетный менеджер емакса и запустив команду nrepl-jack-in (вместо ставшей уже привычной clojure-jack-in), оказалось, что я получил практически такой же REPL с теми же самыми keybinding-ами.

Вообще, на мой взгляд, в последний год в развитии Clojure наметился очень позитивный тренд: заявленные возможности, библиотеки и инструменты работают с полпинка, безо всякой магии. Интересно, встанет ли Clojure в один ряд с таким мейнстримными языками, как ruby или python? Все-таки, инфраструктура Clojure уже довольно хороша и даже относительно user-friendly.

Как я провел лето

Dmitry — Fri, 10 Aug 2012 15:17:00 +0000

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

Вот как выглядит интерфейс этого приложения:

Рис.1 Список абонементов

Рис. 2 Детали абонемента

Рис. 3 Выбран абонемент Чебурашки

Рис. 4 Отчет по оплатам за месяц

На данный момент приложение задеплоено по адресу: http://clubmanager1.com:8080/login . Логин и пароль такие: demo, demo123. (Оперу и IE ниже 9 не подериживаю)

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

Я использовал следующие библиотеки:

[org.clojure/clojure "1.4.0"]
[noir "1.3.0-beta10"]
[com.mysql/connectorj "5.1.12"]
[korma "0.3.0-beta11"]
[cheshire "4.0.1"]
[enlive "1.0.1"]
[enfocus "0.9.1-SNAPSHOT"]

Изначально, для передачи данных из броузера на сервер я использовал JSON, вот почему здесь есть cheshire. Но через некоторое время (и после мощнейшего фейс-палма) обнаружил работающий ридер в ClojureScript, так что оставшиеся данные я передавал уже безо всякого json-а, прямо в виде списков, векторов и мапов Clojure.

Для отрисовки шаблонов изначально использовал Enlive. На клиентской стороне -- порт Enlive-а на ClojureScript, который называется Enfocus.

В общем и целом -- впечатления очень положительные. Серьезных технологических затыков или багов нигде не обнаружил. Правда Enfocus сейчас активно обновляется до версии 1.0.0-SNAPSHOT, но этот снапшот глючный. Автор enfocus-а срочно правит баги, так что скоро увидим и стабильную версию. Версия Enfocus 0.9.1 -- достаточно стабильна и очень похожа на Enlive.

MIT 6.001 читали не тем студентам...

Dmitry — Fri, 13 Jul 2012 11:57:00 +0000

Интереснейшее обсуждение нашел по поводу замены 6.001 на 6.01 в MIT, связанный с отказом от Scheme и переходом на Python. Оказывается, дело не в устаревании курса, такое устареть не может. И не в запредельной хардкороности материала. Все банально и обидно: курс читали электронщикам, которые интересовались больше как построить роботов, нежели красивое и надежное ПО. В новом курсе 6.01, где уже используется Python, материал во многом излагается через применение программирования в робототехнике, что, конечно же, больше подходит для электронщиков.

emacs-template.el

Dmitry — Wed, 20 Jun 2012 14:21:00 +0000

На днях запилил для себя движок темплейтов для emacs lisp-а в стиле Mustache. Использую его для генерации java-кода. Может кому еще пригодится, так что опубликовал его на GitHub.

Велосипед решил пилить потому что CEDET/SRecode оказался для меня слишком сложным в освоении и использовании.

Мой DSL для проектов на Android

Dmitry — Tue, 12 Jun 2012 15:05:00 +0000

Пару месяцев назад перепала мне задачка пилить в одиночку довольно объемный проект на Android. Сам по себе проект был несложный, но количество повторяющегося кода зашкаливало. При том самое обидное, что стандартными средствами как-то избавиться от повторений не представляется возможным. Тогда я и наваял первоначальную версию небольшой генерилки андроид-кода.

Больше всего, конечно, в андроиде меня раздражает xml. Логично, что формочки лучше описывать в декларативном стиле; понятно, что java для этого не годится; разумеется, xml здесь уместен. Но, блин, как же отстойно все это выглядит! Элементарного цикла в нем не сделать, а уж про реюзабельность вообще молчу. Она там, конечно, есть в виде подключаемых пользовательских компонентов. Но все эти механизмы страшно сосут даже по сравнению с инструментами разработки под iPhone!

Самое главное, чего я хотел добиться созданием своего DSL, – это избавиться от богомерзкого xml. Я хотел описывать UI в декларативном стиле на языке общего назначения. Оказалось, что на Clojure – это очень даже просто, достаточно воспользоваться библиотекой hiccup.

Например, вместо этого

<Button android:id="@+id/helloWorldBtn" 
    android:background="@drawable/blue_button_slt"    
    android:layout_height="wrap_content"
    android:layout_width="wrap_content"
    android:text="Push me!"
    android:textColor="#fff"
    android:textSize="10dp"
    android:textStyle="bold"/>

писать такой код:

(Button "helloWorldBtn" wc wc
 [:text "Push me!"
  :textColor "#fff"
  :textSize "10dp"
  :textStyle "bold"
  :background (drawable "blue_button_slt")])

На данном этапе выигрыша в коде почти никакого нет. Зато уже можно сделать, например, так:

(defn large-button [id attributes image & [ txt]]
  (VLayout nil wc wc (conj attributes :gravity "center")
           (ImageButton id "60dp" "70dp"
                        [:background (drawable image)])
           (if-not (empty? txt)
             (TextView nil "125dp" "18dp" 
                        [:text txt
                         :textSize "16dp"
                         :gravity "center"
                         :textColor "#0096c1"]))))

Как видите, введение языка общего назначения вместо xml позволяет легко создавать функции. Напротив, создание реюзабельного компонента под андроид – процедура более долгая и трудоемкая. Еще очень удобно использовать if-ы, loop-ы и прочие возможности языка. Кроме того, код на Clojure писать проще, ведь можно заранее задать для компонентов сокращенные варианты атрибутов либо рациональные настройки. Например, в приведенном выше исходнике wc означает "wrap_content".

Кроме генерации xml на основе приведенного выше примере, можно сгенерировать и код на java. Это позволит автоматизировать многие, часто повторяемые операции.

Рассмотрим пример формы с текстовой строкой и двумя кнопками.

(defn layout []
  (html
   (VLayoutFP nil [:background (drawable "home_bgr")]
    (HLayoutFP nil []
     (VLayoutFP nil []
      (TextView nil wc wc [:text "Demo text"
                 :textColor "#09bbaa"])
      (Button "helloWorldBtn" wc wc [:text "Push me!"
                       :textColor "#fff"
                       :textSize "10dp"
                       :textStyle "bold"
                       :background (drawable "blue_button_slt")
                       :code (->java {}
                                (def ^:String hello "Hello")
                                (def world "world")
                                (System.out.println (+ hello " " world)))])
      (Button "demoBtn" wc wc [:text "Push me!"
                     :textColor "#fff"
                     :textSize "10dp"
                     :textStyle "bold"
                     :background (drawable "blue_button_slt")
                     :code (->java {}

                              (startActivity
                                (new android.content.Intent this OrderScreen.class)))])
      )))))

(generate-activity layout "com.adsl.demo" "MyDemoActivity")

Будет создана связка файлов MVC. Генерятся классы MyDemoActivityModel, MyDemoActivityView, MyDemoActivityController и связываются таким образом, что они сразу готовы к использованию как единая сущность. Будет создана заготовка метода, который вызывается во вьюхе при изменении модели.

public void update(Observable modelObj, Object arg) {
    initialize();
    MyDemoActivityModel model = (MyDemoActivityModel)modelObj;
}

В классе MyDemoActivityView будут созданы атрибуты:

private Button _helloWorldBtn;
private Button _demoBtn;

Позже они инициализируются таким образом:

_helloWorldBtn = (Button) findViewById(R.id.helloWorldBtn);
_demoBtn = (Button) findViewById(R.id.demoBtn);

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

View.OnClickListener listener = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (v.equals(_helloWorldBtn)) {
            controller.helloWorldBtnActionPerformed(MyDemoActivityView.this);
            return;
            }
            if (v.equals(_demoBtn)) {
            controller.demoBtnActionPerformed(MyDemoActivityView.this);
            return;
            }
        }
        };

_helloWorldBtn.setOnClickListener(listener);
_demoBtn.setOnClickListener(listener);

Еще одна забавная штука, которую я добавил скорее по приколу, – это компиляция из моего псевдо-лиспа в java. Кнопке можно задать атрибут :code и прописать туда такое выражение:

(->java {}
         (def ^:String hello "Hello")                  ; Объявить стринговую переменную
         (def world "world")                           ; Объявить нетипизированную переменную
         (System.out.println (+ hello " " world)))   ; Вызвать функцию с параметрами

Генератор преобразует эти выражения в java-код и вставит его в тело метода:

public void helloWorldBtnActionPerformed(MyDemoActivityView view) {
       String hello = "Hello";
       Object world = "world";
       System.out.println(hello + " " + world);
}

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

Например:

(->java {} (startActivity (new android.content.Intent this OrderScreen.class)))

На выходе будет:

public void demoBtnActionPerformed(MyDemoActivityView view) {
       startActivity(new android.content.Intent(this, OrderScreen.class));
}

Сам транслятор содержится в файле clj2java.clj, а главная функция выглядит так:

(defn process
  ([data raw-code]
     (let [code (enrich-with-data data raw-code)]
       (if (list? code)
         (let [elem1 (first code)]
           (cond
            (= elem1 'def) (process-definition code)
            (= elem1 'defn) (process-func-definition code)
            (= elem1 'do) (process-command-sequence (next code))
            (= elem1 'set!) (process-assignment (next code))
            (= elem1 'if) (process-if (next code))
            (= elem1 'return) (process-return (next code))
            (= elem1 '->) (process-method-call (next code))
            (= elem1 'lambda-interface) (process-lambda-interface)
            (= elem1 'lambda) (process-lambda code)
            (= elem1 'call) (process-call (next code))
            (= elem1 'loop) (process-loop (next code))
            (= elem1 'new) (process-new (next code))
            :else (process-function-call code)))
         (process-single-value code))))
  ([raw-code] (process {} raw-code)))

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

Сам же язык описания интерфейсов построен с применением барьеров абстракции, как об этом рассказывается в SICP и On Lisp. Весь код содержится в файле util.clj.

На нижнем уровне абстракции находятся различные служебные функции и ядро всех будущих компонентов – функция виджет:

(defn widget [type id width height params-raw & more] . . . )

Все прочие виджеты создаются на основе этой функции, например, так:

(defn Button [id width height & [params]]
  (widget "Button" id width height (apply android params)))

(defn HLayoutWC [id & [params & more]]
  (widget "LinearLayout" id "wrap_content" "wrap_content" 
          (merge {"xmlns:android" "http://schemas.android.com/apk/res/android"
                  (andr-attr "orientation") "horizontal"}
                 (apply android params))
          more))

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

(defn BlueButton [id width height & [params]]
  (Button id width height (flatten (conj params [:background (drawable "blue_button_slt")
                                                   :textColor "#fff"
                                                   :textSize "10dp"
                                                   :textStyle "bold"]))))

А хелперы для отступа выглядят так:

(defn padding-top [top & more]
  (HLayout nil wc wc [:paddingTop top]
           more))

(defn padding-left [left & more]
  (HLayout nil wc wc [:paddingLeft left]
           more))

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

Плюсы подхода:

Сокращение кода описания активити в три-четыре раза. Чем больше и сложнее описываемая форма – тем больше выигрыш.
Гораздо более простой способ создания абстракций при помощи обыкновенных функций. В результате значительно повышается реюзабельность кода.
Значительно облегчается чтение и модификация кода UI по сравнению с использованием xml.

Минусы:

Сгенеренный код выглядит, порой, написанным copy-paste-ом.
При перегенерации кода теряется код, написанный вручную в сгенеренных ранее файлах.

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

Впечатления о ClojureScript

Dmitry — Sat, 26 May 2012 11:59:00 +0000

На прошлой неделе решил наконец ознакомиться с ClojureScript по-подробнее. До этого я смотрел презентацию Рича Хикки и некоторые другие скринкасты, успел "пощупать" ClojureScriptOne и почитать пару статей о том, как он (ClojureScript) крут. В общем, никаких особых сложностей с ним я не ожидал, поэтому начавшиеся приключения стали для меня откровенным сюрпризом.

Во-первых, мне не удалось создать browser-connected repl, соединенный со своей html-иной. Я выполнял простые туториалы шаг за шагом, и на этапе соединения у меня ничего не получалось. Тогда я запустил проект samples/repl, входящий в поставку ClojureScript. И все было хорошо до тех пор, пока я не попытался соединиться с веб-страницей. В результате, при помощи Дэвида Нолена и еще нескольких разработчиков ClojureScript выяснилось, что документация чуть-чуть не соответствует. После моих гневных отзывов её (документацию) наконец поправили, а я напишу здесь русский вариант туториала о том, как начать работать с ClojureScript.

1. Качаем с гитхаба последнюю версию ClojureScript.
2. Настраиваем emacs:
a) Создаем файл browser-repl.sh с правами на выполнение:
#!/bin/sh

if [ "$CLOJURESCRIPT_HOME" = "" ]; then
CLOJURESCRIPT_HOME="`dirname $0`/.."
fi

CLJSC_CP=''
for next in lib/: lib/*: src/clj: src/cljs: test/cljs; do
CLJSC_CP=$CLJSC_CP$CLOJURESCRIPT_HOME'/'$next
done

java -server -cp $CLJSC_CP clojure.main -e \
"(require '[cljs.repl :as repl])
(require '[cljs.repl.browser :as browser])
(def env (browser/repl-env))
(repl/repl env)"

б) Прописываем в .emacs настройки для inferior-lisp'a:
(setq inferior-lisp-program "~/clojure/clojurescript/browser-repl.sh")

Здесь "~/clojure/clojurescript/browser-repl.sh" -- естственно, путь к созданному на шаге 2а файлу browser-repl.sh.

3. Добавляем clojurescript/bin в $PATH.

4. Заходим в каталог clojurescript/samples/repl, компилируем исходники: cljsc src/ > main.js

Файл main.js будет позднее использоваться в index.html

Обратите внимание на содержимое файла test.cljs. Он содержит такую строчку:
(repl/connect "http://localhost:9000/repl")
Именно она позволяет затем соединиться с Emacs-ом.

5. Файлы index.html, main.js и каталог out необходимо захостить на каком-нибудь веб-сервере. Я, например, просто создал каталог Tomcat7/webapps/my и сложил туда все это барахло. В моем случае страница index.html стала доступна по адресу localhost:8080/my/index.html.

Внимание! Хостить страницу обяхательно, просто открыв её как файл с диска вы не сможете к ней подконнектиться из Emacs-а!

6. Запускаем Emacs, выполняем команду M-x inferior-lisp.

7. Вводим следующие команды:
(require '[cljs.repl :as repl])
(require '[cljs.repl.browser :as browser])
(def env (browser/repl-env))
(repl/repl env)

8. Загружаем/обновляем index.html в броузере. После этого repl в Emacs-е должен заработать. Например, вычисление (+ 1 1) должно выдать ответ 2. Если это произошло -- вуаля! у вас веб-консоль прямо в Emacs-е!

В моем примере index.html содержит следующий фрагмент:

      <div id="dates">
 <div>23.05.2012</div>
 <div>25.05.2012</div>
 <div>27.05.2012</div>
 <div>28.05.2012</div>
 <div>29.05.2012</div>
      </div>

Таким образом, команды на скриншоте изменяют размер шрифта и цвет текста первой даты.

Вообще, документация на ClojureScript достаточно бедная. Поэтому, вместо того, чтобы искать блог-посты и туториалы по использованию ClojureScript, я просто стал читать его исходники. Рекомендую для этого воспользоваться инструментом Marginalia. С Leiningen 2 это вообще просто.

1. В .lein/profiles.clj добавьте плагин lein-marginalia

{:user {:plugins [ [lein-marginalia "0.7.0"]
[lein-pprint "1.1.1"]
[lein-swank "1.4.4"]]}}

2. Создайте новый проект: lein new clj-docs
3. Скопируйте в катлог cljs-docs/src содержимое каталогоа cljorescript/src.
4. Выполните команду lein marg, и в каталоге docs будет создан файл uberdoc.html, который слева содержит комментарии к исходнику, а справа -- сам исходник.

Еще стоит ознакомиться с Google Closure API -- тоже полезное подспорье в работе с ClojureScript.

Ну а в целом, ClojureScript мне очень понравился, и я надеюсь использовать его дальше в своих проектах.

Гусеничный Lisp-трактор

Dmitry — Tue, 08 May 2012 16:55:00 +0000

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

1) Список f содержит всего одну функцию. Её и запускаем первой.
2) Первая функция передает свой код в update.
3) Update "препарирует" код, находит номер текущей итерации, инкрементирует его и собирает такую же функцию, как ей передали, но с новым значением итерации.
4) Первая функция получает вторую функцию и добавляет её в конец списка f. Если список f содержит более трех элементов, то первый элемент списка f удаляется. Таким образом, в списке f содержится не более четырех элементов.
5) Первая функция запускает вторую функцию и завершается.

Выглядит и впрямь, как гусеничный трак :-)

(defn update [func]
  (let [p (nth func 2)        ;; Получить список (println (str "Hi for the " 1 " time!"))
        n (nth (second p) 2)  ;; Получить 1 из списка
        ;; Создать список (println (str "Hi for the " 2 " time!"))
        new-p (cons 'println (list (map #(if (= n %) (inc n) (identity %)) (second p))))]
    ;; Заменить в теле функции (println (str "Hi for the " 1 " time!"))
    ;; на (println (str "Hi for the " 2 " time!"))
    (map #(if (and (seq? %) (= (first %) 'println)) new-p (identity %)) func)))

(def f (ref ['(fn []
                (println (str "Hi for the " 1 " time!"))
                (let [func (last @f)
                      ;; Обновить список функций f
                      ;; Удалить первую функцию, если список f содержит больше трех элементов
                      new-f (if (> (count @f) 3)
                              ;; Добавить обновленную функцию в конец списка
                              (conj (vec (drop 1 @f)) (update func)) 
                              (conj @f (update func)))]
                  (dosync (ref-set f new-f))
                  ;; Выполнить последнюю функцию списка
                  ((eval (last @f)))))]))

((eval (last @f)))

CEDET 1.1, Emacs и Java

Dmitry — Mon, 07 May 2012 15:03:00 +0000

Недавно вышедший Cedet 1.1 добавляет долгожданную поддержку импорта символов из jar-ок. Теперь Emacs предоставляет поддержку автодополнения кода java примерно на том же уровне, что и современные IDE.

Например, у нас есть класс My1:

Он используется в My2:

Обратите внимание, как flymake параллельно скомпилировал файл и подсветил ошибки. Если набрать “my.” и выполнить функцию semantic-ia-complete-symbol-menu (у меня она замаплена на Ctrl-Space), то Emacs выдаст такую подсказку:

Аналогично можно запрашивать подсказку по членам системных классов. Например, для StringBuilder:

Правда надо учитывать, что, во-первых, импорты “звёздочкой” не срабатывают, системных классов semanticdb-javap тоже не знает. Поэтому, если необходимы подсказки, то импорт классов из неймспейса java.lang нужно делать явно, как в моем примере.

Для того, чтобы заработали показанные выше механизмы, необходимо следующее:

установленный пакет flymake;
установленный пакет auto-complete;
скачанный CEDET 1.1;
Ну и конечно же, последний Emacs и java.

Конфигурация CEDET в .emacs :

(load-file "~/cedet/common/cedet.el") ;; Подгрузить cedet

(global-semanticdb-minor-mode 1) ;; Инициализировать semanticdb

;; Загрузить поддержку авто-дополнения

(semantic-load-enable-gaudy-code-helpers)

(custom-set-variables ;; Инициализация переменных, указывающих, где

;; установлена java

. . .

'(cedet-java-jdk-root "/opt/jdk")

;; Сюда нужно добавить все jar-ки, из

;; которых необходимо импортировать символы

'(semanticdb-javap-classpath '("/opt/jdk/jre/lib/rt.jar"))

. . .

)

Конфигурация flymake:

(require 'flymake)

(add-hook 'java-mode-hook 'flymake-mode-on)

(defun my-java-flymake-init ()

(list "javac" (list (flymake-init-create-temp-buffer-copy

'flymake-create-temp-with-folder-structure))))

(add-to-list 'flymake-allowed-file-name-masks '("\\.java$" my-java-flymake-init flymake-simple-cleanup))

Конфигурация auto-complete:

(require 'auto-complete-config)

(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")

(ac-config-default)

Итоги за месяц

Dmitry — Thu, 29 Mar 2012 11:59:00 +0000

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

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

Проект, который я делал с начала февраля по середину марта, -- андроид-приложение для планшетов. Оно предназначалось для дистанционного обучения какой-то фигне сотрудников какой-то компании. Технических сложностей там никаких нету, писать здесь не о чем, за исключением достаточного большого объема работы: необходимо было реализовать 22 формы со всякими разными украшениями. Дополнительная сложность -- необходимо написать еще и JSON веб-сервис, который может отдавать запрашиваемые данные и сохранять у себя ответы пользователей на опросы и тесты.

Дедлайн был очень жесткий: 12 марта. На мой взгляд, при таких объемах и сроках проект должен делать не один человек, а как минимум трое.

Во-первых, мне удалось уговорить заказчика разрешить писать веб-сервис на Clojure вместо java. По моим прикидкам, это сэкономило бы мне неделю работы. Для заказчика были крайне важны сроки, и он позитивно воспринял мое предложение, но поинтересовался: какие минусы у clojure? Я честно сказал, что этот язык просто менее распространен, чем java. Все остальное -- то же, что и у java. Например, готовый сервис мы захостим под Tomcat в виде war-файла. Заказчик согласился с этим риском, заметив, что если вдальнейшем будет необходимость, то тогда вебсервис можно будет переделать на java. Забегая вперед скажу, что необходимость не возникла :-)

Я воспользовался библиотеками noir1.3-alpha10, cheshire, sqlkorma, lobos и очень быстро показал работающий сервак. Функциональность в сервак я добавлял в процессе работы над клиентской частью по мере необходимости. Поскольку я пользовался связкой Emacs+Slime, рабочий код я получал очень быстро. А время, которое я тратил на разработку очередной функции сервака, в среднем равнялось нескольким минутам.

Основное время, конечно же, занимала Android-часть, причем в основном -- настройка внешнего вида формочек. Android -- неплохая платформа для пользователя, но очень сырая и недоделанная для разработчика. В отличие от ябловодов, нам, андроидам, нет возможности пользоваться WYSIWYG-редактором для построения GUI. А редактировать гигантские простыни xml-кода вручную -- сомнительное удовольствие...

Решение нашлось довольно быстро. Я разработал небольшой DSL на основе Clojure и Hiccup. С применением этого DSL формочку я целиком описывал на Clojure, а потом генерил из неё связку xml и java-кода (при этом генерился весь MVC на форму). В среднем, количество кода в DSL и количесство сгенеренного xml+java кода соотносились как 1:3 или 1:4, что уже очень неплохо. Еще один важный бонус, который я получил от этого DSL -- возможность использования нормального вменяемого языка для описания UI вместо XML. Появилась возможность выносить общую функциональность в функции, делать циклы и т.д. Понятно, что большинство повторно используемых компонент оформлялись как отдельные виджеты; но там, где для этого не было необходимости -- я просто объявлял функцию на Clojure. Еще важное замечание: код в стиле Hiccup читается гораздо проще, чем xml.

Дальше развивать свой DSL у меня уже не было времени, а повторяющийся код, который я не мог обобщить, все равно встречался. Например, код для работы с БД и вебсервисом состоял по большей части из извлечения-записи в хеш-таблицы по ключам, соответствующим именам полей в БД. Здесь мне на помощь пришел Emacs. Буквально пара десятков строк кода на elisp-е, и весь оставшийся boilerplate-код на java генерил Emacs.

Надо сказать, что в сроки я уложился, но с учетом, что в конце проекта на 2 недели мне дали в помощь товарища. Думаю, получилось очень даже хорошо.

Деплоймент Clojure под Tomcat

Dmitry — Sun, 19 Feb 2012 11:35:00 +0000

Не так давно я взялся за небольшой проект с клиент-серверной архитектурой. JSON веб-сервис мне позволили реализовать на clojure, что я очень быстро и сделал при помощи библиотек: Noir, Lobos, Korma и Cheshire. Но зато была масса непоняток с деплойментом этого готового сервиса на хостинг. Во-первых, по непонятной причине, оригинальный сервер, поработав какое-то время, попросту отваливается. Я до сих теряюсь в догадках, что заставляет его так капризничать. Понятное дело, что я решил задеплоить всё на Tomcat.

Мне не удалось нигде найти нормальной инструкции о том, как деплоить noir-приложение под томкат, так что я решил восполнить этот пробел.

Данная инструкция рассчитана на веб-сайт, разработанный на clojure при помощи фреймворка Noir (опробовано на noir 1.3.0-alpha10).

1) Добавьте [lein-ring "0.5.4"] в :dev-dependencies вашего файла project.clj.
Внимание! [uk.org.alienscience/leiningen-war "0.0.13"] – это не то же самое, что lein-ring. Плагин lein-ring умеет создавать ring-handler для noir-приложения и запаковать все в war-ку. А плагин leiningen-war только создает war-ку, а ring-handler-а не создает.

2) В файле project.clj укажите ваш ring-handler и пространство имен для ahead-of-time компиляции.
:ring {:handler MyProject.server/handler}
:aot [MyProject.server]

3) Создайте ring-handler в server.clj:
(:require [noir.server :as server])
. . .
(def handler (server/gen-handler {:base-url "/myproject"}))
Внимание! Обязательно нужно указать :base-url, иначе редиректы и линки задеплоенного в томкат приложения будут указывать не на localhost:8080/myproject/, а на localhost:8080/ . Эпик фейл будет фееричный!

4) Уберите такую загрузку вьюх: (server/load-views "src/MyProject/views/") из файла server.clj. Вьюхи нужно загружать явно:
(:require [noir.server :as server]
. . .
[MyProject.views.pages])
Если этого не сделать, то после упаковки в war-ку и даже jar-ку, ни один ваш маршрут работать не будет.

5) Все линки и формы, если вы их генерите из hiccup, нужно создавать функциями:
(hiccup.form-helpers/form-to [:post "/myurl"] ...)
(hiccup.page-helpers/link-to "/myurl" …)
Если этого не сделать, то они будут вести на localhost:8080/ вместо localhost:8080/myproject.

6) Создайте war-ку командой lein ring uberwar.
Внимание! Команда lein ring uberwar поставляется с lein-ring-плагином, и в нашем случае она работает. Команда lein uberwar поставляется с плагином leiningen-war, и здесь она не работает. Так что этот плагин вообще лучше не использовать с noir.

7) Скопируйте war-ку в webapps томката и переименуйте её в myproject.war.

Теперь, после запуска томката, по адреусу localhost:8080/myproject будет ваше приложение.

Noir benchmark

Dmitry — Sun, 22 Jan 2012 18:01:00 +0000

Решил немного потестить простое веб-приложение, описанное в предыдущей статье. Тесты проводились на ноутбуке Acer Aspire 5745G (Intel Core i5 2.26Ghz, 4Gb). Обнаружил следующее.

Во-первых, при запуске сайта командой lein run запускаются два java-процесса. Первый, занимающий 28.8Mb -- видимо служебный, т.к. никакие его характерстики за время работы приложения не менялись. Второй, сходу запросивший 76.7Mb, -- само веб-приложение. Я создал два типа сущностей: mypage и mypage2 с CRUD-действиями для них, не используя БД. Т.е. скорость обработки запроса целиком зависила от скорости работы java-машины и не зависела от скорости ввода-вывода или поиска данных в таблицах. При обращении к различным действиям сущности mypage объем потребляемой памяти возрос до 90.3Mb. При обращении к mypage2 -- до 93.5Mb. При повторном обращении к этим же сущностям потребление памяти никак не поменялось. При перезапуске приложения цифры изменились до 96Mb и 99Mb.

Интересно взглянуть на производительность веб-приложения под нагрузкой. Я создал скрипт, делающий 70000 таких запросов:
wget http://localhost:8080/mypage
wget http://localhost:8080/mypage/848867
wget http://localhost:8080/mypage/edit/996283
wget http://localhost:8080/mypage/527997
wget http://localhost:8080/mypage/edit/410389

Сущности с указанными айдишниками, естественно, существовали в приложении. Эти 70тыс. запросов jetty обработал за полчаса, отдавая, таким образом, примерно 2333 динамических страницы в минуту или примерно 39 в секунду.

Самым интересным для меня в этом эксперименте стало потребление памяти и процессорного времени.

Сначала jetty затребовал 92% процессорного времени, но его запросы довольно быстро сократились до 40%. Затем, довольно медленно, и они стали снижаться. К концу эксперимента jetty потреблял всего 4% процессорного времени.

Аналогично, запросы памяти сначала были немалыми. Довольно быстро jetty "откушал" 232.8Mb, после чего потребляемая память стала уверенно снижаться, остановившись на отметке 84.6Mb.

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

Такое снижение потребляемой памяти и процессора стало возможно благодаря run-time оптимизациям java-машины (в Sun некогда здорово над этим поработали). Вот и скажи теперь, что java -- медленная...

CRUD на Clojure средствами Noir

Dmitry — Sun, 08 Jan 2012 12:22:00 +0000

Давно собирался рассказать немного о Noir – классном веб-фреймворке для Clojure. Наконец, у меня появилась возможность написать большой туториал по применению Noir, что я с удовольствием и сделаю :-)

Есть ли вообще необходимость в самоучителе по Noir? Не очень существенная, если честно. На сайте фреймворка (webnoir.org) более чем приличная документация: раздел для быстрого старта, несколько обучалок по использованию Noir и даже индекс API. Мой туториал, возможно, будет вам полезен, если вы, зная Clojure и разобравшись более-менее с Noir, все еще не очень представляете себе архитектуру своего будущего приложения.

А задуматься над архитектурой придется. Noir очень сильно отличается от всех известных мне фреймворков. При своем минимализме он оставляет выбор конкретных библиотек за пользователем – такая свобода может привести к неверному их использованию. Насколько этот выбор широк можете судить хотя бы по статье с обзором разных компонентов для каждого из уровней веб-стека на clojure.

Давайте посмотрим, на что похоже приложение Noir. Если вы проследовали инструкциям из Getting Started на сайте webnoir.org, то у вас уже установлен leiningen-плагин для Noir. Создадим новый проект командой lein noir new optimalist. У него очень простая структура.

resources – содержит каталог public со статическим контентом (css, javasript, images);

src – каталог с исходниками;

test – тесты;

project.clj – описание проекта и версий подключаемых библиотек.

Исходники содержаться в двух каталогах src/optimalist/views и src/optimalist/models. Никаких вопросов не вызывает? А как насчет src/optimalist/controllers? Такого каталога нету, т. к. самописных контроллеров здесь не предусмотрено. Это, конечно, у многих может вызвать разрыв шаблона: как вообще программировать MVC без C!

Автор Noir Крис Гранжер очень подробно обосновал свое представление архитектуры. Исторически сложилось, что бизнес-логику обычно помещали в контроллер. Но со временем её все больше и больше выносили в отдельные компоненты, контроллер стал совсем тоненьким и, откровенно говоря, ненужным. Функции маршрутизации берет на себя фреймворк, так что в Noir (да и в других современных веб-фреймворках) строгой необходимости в отдельных контроллерах попросту нету. Единственное, что всё еще делает контроллер – это указывает, какую страницу рендерить в ответ на запрос пользователя. Раз уж код контроллера такой маленький, то Крис Гранжер попросту решил перенести функции контроллера на уровень View.

Если сравнивать такой подход с другими фреймворками, то, пожалуй, Крис – один из первых, кто открыто решился заявить о ненужности контроллеров. Например, в практике программирования Ruby on Rails всё еще считается правильным всю бизнес логику вынести на уровень модели, а контроллеры сделать маленькими и легковесными. Это очень упрощает тестирование. Но это половинчатый подход: выбросили бы контроллеры да и дело с концом! Скажем, в JSF2.0 примерно так и обстоят дела. Вся бизнес-логика находится в Java-бинах, вызываются они с уровня View напрямую, минуя слой контроллера. Маршруты привязываются к страницам обычно централизованно в специальном файле конфигурации.

Поскольку каталог models пустой, давайте взглянем повнимательнее на содержимое каталога views.

В файле common.clj создается специальная функция layout. Она задает общий шаблон страницы, заголовки и структуру html-файла.

В файле welcome.clj при помощи defpage задается маршрут «/welcome» и функция, которая сгенерирует ответ на запрос пользователя по этому маршруту. Как видно из кода, функция вернет строку приветствия. Шаблон html-страницы создается при помощи библиотеки Hiccup. Она позволяет писать html-код прямо на языке clojure при помощи родных для clojure структур данных: векторов и мапов.

Hiccup очень удобен тем, что позволяет производить любые манипуляции с шаблоном прямо при помощи Clojure. Заметьте, такой подход вообще не встречается среди мейнстримных фреймворков. Что в ASP.NET, что в J2EE для разметки страницы применяется свой собственный DSL, построенный на базе XHTML. Как, например, сделать повторяющийся фрагмент страницы на JSF2.0, на которой еще есть экшены? Правильно, с применением ломика и какой-то матери. В ASP.NET с этим, вроде, несколько проще, но подход такой же: xml-теги. Ну и скажите мне, как программисту Java, почему я не могу использовать Java для изменения шаблона веб-страницы? Как ни крути, но даже Java... хотя нет, уж лучше этот долбаный XML, чем веб-страницы на Java...

Короче, в Noir используется hiccup, а hiccup позволяет писать html-страницы на clojure в декларативном стиле.

Вручную hiccup-код имеет смысл писать только для страниц очень небольшого размера. Если вам досталась от дизайнера монстрозная страница в десятки килобайт кода – конечно, такое поделие переписывать на hiccup не стоит. В этом вам поможет clj-tagsoup. Просто вызовите его функцию parse с указанием html-страницы и сохраните полученный hiccup-код.

Почти все руководства о веб-фреймворках в виде первого учебного приложения предлагают свой вариант блога. Давайте и мы сделаем свой простой блог при помощи Noir. Переименуем welcome.clj в article_pages.clj (а также namespace) и напишем код первой страницы блога – списка записей. Еще я немного изменил список импортируемых библиотек.

(ns optimalist.views.article_pages
  (:require [optimalist.views.common :as common]
            [noir.response :as resp])
  (:use [noir.core]
        [hiccup.core]))

(defpage articles "/articles" []
         (common/layout
           [:p "List of articles"]))

Обратите внимание, что маршрут «/articles» – именованный. В будущем я смогу получить его при помощи (url-for articles).

Запустите веб-приложение командой lein run и откройте его по ссылке localhost:8080/articles. Разумеется, вы увидите текст «List of articles». Но пока что еще не работает корневой маршрут: localhost:8080/. Давайте добавим для него определение маршрута.

(defpage "/" []
  (resp/redirect (url-for articles)))

Как видите, здесь объявляется неименованный маршрут «/», и вместо ответа на него сервер редиректит на страницу articles.

Следующая проблема: как вывести список каких-либо элементов? Поскольку код шаблона мы пишем на clojure, то воспользуемся функцией for:

(defpage articles "/articles" []
  (let [data [{:id 1, :title "First title", :body "First body"}
              {:id 2, :title "Second title", :body "Second body"}
              {:id 3, :title "Third title", :body "Third body"}]]
         (common/layout
          [:p "List of articles" [:br] [:br]
           (for [item data]
             [:div
              (:title item)
              [:br]
              (:body item)
              [:br][:br]])])))

Пока что все достаточно просто, не так ли? Страница articles покажет нам следующий текст:

List of articles

First title
First body

Second title
Second body

Third title
Third body

Теперь данные нужно перенести в отдельный файл. Создадим в каталоге models файл article_model.clj, добавим туда код:

(ns optimalist.models.article_model)

(def *data*
  (ref
   [{:id "1", :title "First article", :body "Lorem ipsum dolor sit amet."}
   {:id "2", :title "Second article", :body "Lorem ipsum dolor sit amet."}
   {:id "3", :title "Third article", :body "Lorem ipsum dolor sit amet. "}
   {:id "4", :title "Fourth article", :body "Lorem ipsum dolor sit amet."}]))

(defn fetch-list []
  @*data*)

Воспользуемся этой моделью. Чтобы импортировать модель, добавим в секцию require такую строку: [optimalist.models.article_model :as article-model]; а код функции articles перепишем таким образом:

(defpage articles "/articles" []
  (common/layout
   [:p "List of articles" [:br] [:br]
    (for [item (article-model/fetch-list)]
      [:div
       (:title item)
       [:br]
       (:body item)
       [:br][:br]])]))

Вообще такая организация кода всё еще не очень удобная. Что если будет несколько страниц с похожим функционалом? Нам придется выносить hiccup-код в отдельные модули чтобы сделать его reusable. Давайте сделаем это сразу. Создатим файл view/article_templates.clj и вынесем туда генерацию httml.

(ns optimalist.views.article_templates
  (:use [noir.core]
        [hiccup.core]))

(defn show-list [articles-list]
   [:p "List of articles" [:br] [:br]
    (for [item articles-list]
      [:div
       (:title item)
       [:br]
       (:body item)
       [:br][:br]])])

В модуле article_pages.clj необходимо добавить строку [optimalist.views.article_templates :as article-view] в секцию :require. А страница articles тогда будет выглядеть так:

(defpage articles "/articles" []
  (common/layout
   (article-view/show-list (article-model/fetch-list))))

Следующая наша задача – добавить к элементам списка ссылки на действия. Лично я – большой любитель технологии REST, о которой узнал из Ruby on Rails. Наши четыре действия над сущностью create, read, update, delete подразумевают наличие семи маршрутов:

Маршрут	Метод	Описание
/articles	GET	Список записей
/article/:id	GET	Просмотреть одну запись
/article/edit/:id	GET	Показать форму редактирования записи
/article/update/:id	POST	Изменить запись в соответствии с указанными данными
/article/delete/:id	POST	Удалить запись
/article/new	GET	Показать пустую форму для создания записи
/article/create	POST	Создать запись в соответствии с указанными данными

Вообще в REST должны использоваться методы не только GET и POST, а также PUT (для создания новой записи) и DELETE (для удаления). Но то ли браузеры не понимают этих методов, то ли веб сервера, но факт остается фактом: использовать мы можем только GET и POST. В Ruby on Rails для обхода этого ограничения создается скрытое поле. И если указывается метод PUT или DELETE, то на самом деле используется POST с пометкой в скрытом поле, что это все-таки PUT/DELETE.

Разные методы отправки запроса нужно использовать не только для красоты. По сети ползают роботы-индексаторы, которые пытаются перейти по ссылкам на другие страницы. Представьте, например, что на вашем сайте кнопка DELETE сделана при помощи обыкновенной ссылки (запрос методом GET), и робот решит по ней перейти. Робот ведь не знает, что эта ссылка приводит к какому-то разрушительному действию, правда? Вот для этого-то все запросы, как-нибудь изменяющие сущность, должны быть отправлены методом POST.

Итак, первая ссылка, которую я хотел бы добавить к списку сущностей – маршрут /article/:id для просмотра записи.

Вначале в article_pages добавим страницу:

(defpage view-article "/article/:id" {id :id}
  (common/layout
   "View article"))

Она пока ничего не делает, но зато её сразу же можно протестить в браузере по маршруту /article/1. Заметьте, что в определении страницы задан хеш параметров {id :id}. Это деструктуризаця параметров запроса, и делает она именно то, на что похоже: создает локальную переменную id, значение которой будет получено из части маршрута :id.

Теперь добавим ссылку на эту страницу в функции show-list

(defn show-list [articles-list]
   [:p "List of articles" [:br] [:br]
    (for [item articles-list]
      [:div  (:title item) [:br]
       (:body item) [:br]
       [:a {:href (url-for (str "/article/" (:id item)))} "View"]
       [:br][:br]])])

Функция url-for умеет создавать абсолютный URL по заданным параметрам. Параметром может быть как текстовая строка с маршрутом, так и сам именованный маршрут. И хотя предложенное выше решение – вполне работоспособное, но оно все-таки не оптимальное. Что если вы решите изменить URL в странице view-article? Тогда вам придется искать все места, где вы на него ссылаетесь, и править маршруты вручную. Лучше использовать именованый маршрут следующим образом:

(url-for optimalist.views.article_pages/view-article {:id (:id item)})

Здесь optimalist.views.article_pages/view-article – полное имя именованного маршрута. Необходимо писать его целиком, т. к. в файле article_templates.clj ничего не известно о aricle_pages.clj. И импортировать article_pages.clj мы тоже не можем, т. к. там уже есть импорт article_templates.clj, и мы получим циклическую зависимость. Поэтому, все-таки, придется писать целиком.

Второй параметр – хеш значений, которые будут переданы в генератор маршрута. Поскольку наш маршрут выглядит как «/article/:id», то ему нужно передать хеш {:id <значение>}.

Вообще, конечно же, такая запись жутко громоздкая и неудобная. Поэтому в начало файла article_templates.clj, после объявления неймспейса, добавим алиас:

(alias 'article 'optimalist.views.article_pages)

Теперь генерацию ссылки можно переписать таким образом:

(url-for article/view-article {:id (:id item)})

Это уже значительно лучше, но все еще пока не идеально. Элементов типа «ссылка» у нас будет достаточно много, особенно, если много разных сущностей. Но типов ссылок всего несколько: new, view, edit, delete, back. Мы могли бы сделать более абстрактный механизм генерации ссылок, который инкапсулирует в себе всю внутреннюю структуру вектора [:a …], в том числе и надпись на ссылке. Создадим файл views/helpers/widget.clj:

(ns optimalist.views.helpers.widget
  (:require [noir.core]))

(defmacro view-link [page id]
  `(vec [:a
     {:href (noir.core/url-for ~page {:id ~id})} "View"]))

Теперь его можно подключить в article_templates.clj, добавив строку [optimalist.views.helpers.widget] в секцию :use. А вместо записи [:a {href … } «View»] вставим вызов макроса: (view-link article/view-article (:id item)).

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

Сам макрос пока-что не слишком удачный. Что если нам понадобится добавить еще несколько похожих ссылок? Copy-paste – не наш метод, поэтому немного расширим наш язык для данного конкретного случая.

Это очень интересная технология, описанная Полом Грэмом в книге «On Lisp», и называется она «bottom-up programming». Идея заключается в том, что вы не только пишете свое приложение, используя Lisp, но и изменяете Lisp, чтобы легче было писать ваше предложение. Снизу, в язык вводятся новые конструкции, упрощающие реализацию приложения. Сверху, приложение описывается при помощи ваших новых конструкций, что делает код значительно короче. Отсюда и bottom-up programming.

Новые конструкции, которые мы вводим в язык, называются утилитами. Давайте добавим две таких:

(defmacro common-url [page id]
  `(noir.core/url-for ~page {:id ~id}))

(defmacro common-link [url text & params]
  `(vec [:a (merge {:href ~url} ~@params) ~text]))

Первый макрос просто инкапсулирует знание о том, как создавать URL. Теперь нам не надо заботиться о том, чтобы дописывать noir.core к url-for, а также создавать хеш для единственного занчения id.

Второй макрос создает html-ссылку с заданным текстом на указанный URL. Необязательный параметр params – это возможные параметры самой ссылки. Например, если нам потребуется задать обработчик onclick, то мы сможем сделать это через params.

Перепишем текст генерации ссылки с применением двух новых утилит:

(defmacro view-link [page id]
  `(common-link (common-url ~page ~id) "View"))
  
(defmacro edit-link [page id]
  `(common-link (common-url ~page ~id) "Edit"))

Итак, на данный момент, у нас есть список записей и ссылка на просмотр каждой записи. Давайте теперь реализуем функцию view-article:

(defpage view-article "/article/:id" {id :id}
  (common/layout
   (article-view/show
    (article-model/fetch id))))

Чтобы она заработала, нужно в article_templates добавить функцию show:

(defn show [article]
  [:div
   [:h1 (:title article)]
   [:div (:body article)]
   [:br]
   [:a {:href (url-for article/articles)} "Back"]])

В article_model необходимо добавить функцию fetch:

(defn fetch [id]
  (first
   (filter #(= id (:id %)) @*data*)))

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

article_pages.clj

(ns optimalist.views.article_pages
  (:require [optimalist.views.common :as common]
            [noir.response :as resp]
            [optimalist.views.article_templates :as article-view]
            [optimalist.models.article_model :as article-model])
  (:use [noir.core]))

(defpage "/" []
  (resp/redirect (url-for articles)))

(defpage articles "/articles" []
  (common/layout
   (article-view/show-list (article-model/fetch-list))))

(defpage view-article "/article/:id" {id :id}
  (common/layout
   (article-view/show (article-model/fetch id))))

(defpage edit-article "/article/edit/:id" {id :id}
  (let [item (article-model/fetch id)]
    (common/layout
     (article-view/form (url-for update-article {:id id}) "Update" (:title item) (:body item)))))

(defpage update-article [:post "/article/update/:id"] {:keys [id title body]}
  (article-model/update id title body)
  (resp/redirect (url-for view-article {:id id})))

(defpage new-article "/article/new" []
  (common/layout
   (article-view/form (url-for create-article) "Create")))

(defpage create-article [:post "/article/create"] {:keys [title body]}
  (article-model/create title body)
  (resp/redirect (url-for articles)))

(defpage delete-article [:post "/delete/:id"] {id :id}
  (article-model/delete id)
  (resp/redirect (url-for articles)))

article_templates.clj

(ns optimalist.views.article_templates
  (:require [optimalist.views.helpers.widget :as widget])
  (:use [noir.core]
        [hiccup.core]))

(alias 'article 'optimalist.views.article_pages)

(defn show [article]
  [:div
   [:h1 (:title article)]
   [:div (:body article)]
   [:br]
   [:a {:href (url-for article/articles)} "Back"]])

(defn list-item [item]
  (let [id (:id item)]
    [:div [:div (:title item)]
     (:body item)
     [:form {:id (str "form-" id) :method "POST", :action (url-for article/delete-article {:id id})}
      [:div
       (widget/view-link article/view-article id) " | "
       (widget/edit-link article/edit-article id) " | "
       (widget/delete-link id)]]
     [:br][:br]]))

(defn show-list [articles-list]
  [:div
   (for [item articles-list] 
     (list-item item))
   [:a {:href (url-for article/new-article)} "New"]])

(defn form [url button-text & [title body & rest]]
  [:form {:method "POST", :action url}
   [:input {:name "title", :type "text", :value title}]
   [:br]
   [:textarea {:name "body"} body]
   [:br]
   [:input {:type "submit", :value button-text}]
   [:br]
   [:a {:href (url-for article/articles)} "Back"]])

Субботний вечер пропаганды маргинальных технологий: Статистический анализ с помощью clojure и incanter

Pavel Drobushevich — Sat, 26 Mar 2011 22:39:00 +0000

Начну из далека. Все прекрасно знают, что Java код компилируется в платформа независимый java bytecode. Sun'ики этого не планировали, но, так же как и для CLR, появились альтернативные языки, компилируемые под JVM. Зачастую это порты других известных языков: Jython (Python), JRuby (Ruby), Kawa (Scheme). Они пользуются небольшой популярностью по очевидной причине, люди предпочитают использовать не порт, а настоящий язык. Но есть языки разработанные специально для JVM. Например Groovy, солянка Ruby и Java, заполучил своё место под солнцем как скриптовый язык, часто используется, как основа более гибких конфигураций, нежели статический xml и вроде веб на нём тоже делают. Ещё есть Scala, мельтипарадигменный язык, который совмещает в себе огромную кучу фич из ООП и ФП. Мне он не очень нравится перегруженностью синтаксиса, но он набирает популярность как замена Java. Но сегодня я хотел бы поговорить о Clojure - это функциональный язык, диалект великого Lisp'а. Ах, нет, я хотел обмануть, про замечательный язык clojure я не стану рассказывать детально в этой статье, лучший способ с ним познакомиться это одноименный раздел на сайте Алекса Отта. Там же есть постоянно обновляющаяся вводная статья написанная Алексом для журнала fprog.

Я участвую в проекте по обработке данных. Предыдущая версия использовала MS Sql Server для своей работы, поэтому анализ работы системы сделать было достаточно просто, можно было обойтись и простым t-sql скриптом или, если нужно было графическое представление, то можно было использовать Reporting services. Сейчас же, для того компонента, которым я занимаюсь, никакие СУБД не используются, поэтому какие-то выводы можно делать исключительно по логам. Поэтому даже был сделан отдельный структурированный лог в csv формате обо всех важных событиях, произошедших в системе. К примеру, к нам приходит много файлов, поэтому для каждого из этих фалов, этот лог содержит упрощённо 3 записи: файл найден, файл отправлен на обработку, файл обработан. Как то у Ярослава возникла идея попробовать язык R, чтобы нарисовать какие-нибудь интересные аналитические графики. Меня идея заинтересовала, я скачал книгу и впал в ступор. В общем и целом, язык этот мне не понравился (можно сказать не осилил:)). Но месяц назад в очередном порыве изучения clojure, у Алекса наткнулся на упоминания о проекте incanter. Лучше всего его описали сами авторы:

Incanter is a Clojure-based, R-like platform for statistical computing and graphics.

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

Дальше »

Новое в clojure 1.5

Алексей — Sat, 09 Mar 2013 04:15:00 +0000

1 марта был выпущен релиз clojure 1.5. Полный список изменений здесь https://github.com/clojure/clojure/blob/master/changes.md

Теперь для версии clojure 1.5 требуется Java 7 (используется класс java.util.concurrent.ForkJoinPool). Новая версия Java необходима для работы с новым добавленным неймспейсом clojure.core.reducers

Новая библиотека core.reducers призвана увеличить скорость обработки коллекций. Основная оптимизация заключается в том, что последовательность действий над коллекцией (например (filter #() (map #() seq))) не создает промежуточную коллекцию и действия могут выполняться параллельно(при этом код остаётся без изменений)

clojure-1-5.core=> (require ['clojure.core.reducers :as 'r])
nil
clojure-1-5.core=> (def numbers (into [] (range 99999)))
#'clojure-1-5.core/numbers
clojure-1-5.core=> (time (doseq [x (range 100)] (reduce + (r/filter #(> 4 (mod %1 10)) (r/map inc numbers)))))
"Elapsed time: 729.914422 msecs"
nil
clojure-1-5.core=> (time (doseq [x (range 100)] (reduce + (filter #(> 4 (mod %1 10)) (map inc numbers)))))
"Elapsed time: 847.422309 msecs"
nil

Для агентов появилась возможность задать собственный пул тредов для выполнения модифицирующих операций над агентами(с помощью send, send-of, send-via)
Например можно выполнять операции над агентами в один поток(по умолчанию число потоков равно числу ядер + 2)

clojure-1-5.core=> (def a (agent {:a 1}))
#'clojure-1-5.core/a
clojure-1-5.core=> @a
{:a 1}
clojure-1-5.core=> (send a assoc :b 2)
#<Agent@17d577c: {:a 1, :b 2}>
clojure-1-5.core=> @a
{:a 1, :b 2}
clojure-1-5.core=> (set-agent-send-executor! (java.util.concurrent.Executors/newSingleThreadExecutor))
#<FinalizableDelegatedExecutorService java.util.concurrent.Executors$FinalizableDelegatedExecutorService@108fbd4>
clojure-1-5.core=> (send a assoc :c 3)
#<Agent@17d577c: {:a 1, :c 3, :b 2}>
clojure-1-5.core=> @a
{:a 1, :c 3, :b 2}

Для кастомизации функции send используется set-agent-send-executor! для send-off используется set-agent-send-off-executor!. Если нужно выполнить действие над агентом с произвольным исполнителем, можно использовать send-via. В общем случае функцию send следует использовать когда операция занимает фиксированное количество времени, а send-off когда операция может быть заблокирована по I/O или другому внешнему ресурсу.

Начиная с версии 1.5 функции-конструкторы (hash-map, array-map) принимают дублирующие значения ключей и не выкидывают исключения

в версии 1.4

(hash-map :a 1 :b 2 :a 4)
IllegalArgumentException Duplicate key: :a  clojure.lang.PersistentHashMap.createWithCheck (PersistentHashMap.java:92)

в 1.5

(hash-map :a 1 :b 2 :a 4)
{:a 4, :b 2}

объявление литерала c дублирующими ключами по прежнему кидает исключение

{:a 1 :b 2 :a 4}
#<IllegalArgumentException java.lang.IllegalArgumentException: Duplicate key: :a>

К макросам -> ->> добавилось несколько новых макросов cond-> и cond->> для выполнения последовательности действий с условиями, а также есть возможность задать именнованную область с помощью as->

(-> 84
           (/ 4)
           (as-> twenty-one
                  (* 2 twenty-one)))
42

Для последовательности действий, где на промежуточном шаге результат действия может быть nil и необходимо прервать выполнение дальнейших шагов есть макрос some-> (или some->>)

(-> (range 1) next inc)
NullPointerException   [trace missing]
(some-> (range 1) next inc)
nil

Новая версия gen-class позволяет обращаться к protected final методам родительского класса через :exposes-methods

К мета данным (функция meta) добавлен атрибут :column, указывающий номер колонки в исходном файле. До версии 1.5 был указан только номер строки :line

Google использует Common Lisp?

Алексей — Thu, 11 Oct 2012 05:44:00 +0000

Иначе зачем выпускать style-guide https://google-styleguide.googlecode.com/svn/trunk/lispguide.xml?

Нашел только одно упоминание про использование лиспа внутри google
http://googleresearch.blogspot.com/2008/11/plop-probabilistic-learning-of-programs.html

это plop

"A Common Lisp framework for experimenting with meta-optimizing semantic evolutionary search (MOSES) and related approaches to learning with probability distributions over program"

Прошляпил Clojure Conj

Алексей — Fri, 20 Jan 2012 08:16:00 +0000

Оказывается по Clojure была конференция Clojure Conj, аж на целых 3 дня. Проходила она в ноябре 2011 года. Видео доступно здесь.

Что самое приятное, так это то что есть люди заинтересованные в запуске и использовании clojure на Android. На clojure-conj был доклад на эту тему. Правда видео я не нашел. Если у кого есть напишите в комментариях.
Здесь ссылки на презентации докладчиков.

Опережающее объявление макроса

Алексей — Sun, 16 Oct 2011 08:23:00 +0000

Кто-нибудь знает как в clojure сделать опережающее определение макроса?

Такой код не скомпилируется, ошибка - "Unable to resolve symbol: my-inc in this context"

(my-inc 78)
(defmacro my-inc[number] `(+ ~number 1))

А так получишь ошибку в рантайме "Wrong number of args (1) passed to: "

(declare my-inc)
(my-inc 78)
(defmacro my-inc[number] `(+ ~number 1))

Я так понимаю declare приходится писать из за того что компилятор не многопроходный?

Создание экземпляра класса по имени

Алексей — Fri, 01 Jul 2011 11:39:00 +0000

Для создания экземпляра класс в clojure можно воспользоваться специальной формой new

(new String)

или более краткой записью '.'

(String.)

Но не всегда этих средств достаточно. Возникает необходимость создания объекта класса, зная только имя целевого класса(например хранящегося в виде строки "String"). В этом случае объект можно создать воспользовавшись методами java-классов java.lang.Class(для классов с конструктором без параметров) и java.lang.reflect.Constructor - для конструкторов с параметрами.
Первый шаг создания объекта по имени класса - это найти полное имя класса, решается с помощью функции ns-resolve. Поиск выполняется в текущем пространстве имен(*ns*)

(ns-resolve *ns* (symbol "String"))
java.lang.String

В случае успеха ns-resolve возвращает экземпляр класса java.lang.Class.

Если конструктор класса с параметрами, необходимо найти конструктор с подходящей сигнатурой(метод getConstructor класса java.lang.reflect.Constructor). И создать новый объект методом newInstance.
Окончательно функция будет выглядеть так:

(defn new-instance [name & args]
  (let [class (ns-resolve *ns* (symbol name))]
    (if (= java.lang.Class (type class))
      (if args
        (let [type-args (into-array java.lang.Class (map #(type %) args))]
          (.newInstance (.getConstructor class type-args) (into-array args)))
        (.newInstance class)))))

Пример использования

user=> (new-instance "String")
""
user=> (new-instance "String" "abc")
"abc"
user=> (type (new-instance "String" "123"))
java.lang.String

Модификация атрибутов объекта в Clojure

Алексей — Sat, 21 May 2011 06:24:00 +0000

Часто необходимо модифицировать состояние объекта, особенно когда работаешь с java библиотекой, смысл которой сводится к вызову callback'ов и необходимо сохранять промежуточное состояние между вызовами. Например SAX парсер.

Clojure определяет три способа работы с изменяемыми данными. Это ссылки, агенты и атомы. Все они описаны в статье Алексея Отта (http://alexott.net/ru/clojure/clojure-intro/).
Для моего случая подходит синхронное изменение и заворачивать обращения к изменяемым переменным в транзакции нет необходимости. Поэтому я буду использовать атомы(atoms).

Для примера опишем класс com.Example. Объявим одновременно пространство имен и класс(com.Example) с помощью макроса ns.

(ns com.Example
  (:gen-class
    :state state
    :init init
    :constructors {[] []}
    :methods [[setAttr [clojure.lang.Keyword int] void],
              [getAttr [clojure.lang.Keyword] int],
              [removeAttr [clojure.lang.Keyword] void]]
    :main false))

:init - имя конструктора
:state - имя атрибута для хранения состояния объекта
:constructors - описание типов параметров конструкторов класса
:methods - описание доступных методов класса, в формате [имя [тип_параметра ...] тип_возвращаемого_значения]
:main - false - не генерировать, автоматически, метод main(первый метод который будет вызван для java программы)

Теперь код объявленных выше методов.

Конструктор:

(defn -init []

[[] (atom {})])

конструктор без параметров. Конструктор класса в clojure должен вернуть вектор с двумя элементами.

[ [superclass-constructor-args] state]

Первый элемент - еще один вектор, содержит параметры конструктора родительского класса([] - для родительского конструктора без параметров). Второй элемент - значение переменной состояния(имя которой определяется через параметр :state). В нашем случае это хеш(maps). Применение функции atoms делает состояние объекта изменяемым.

После того как state в классе объявлен как изменяемый его можно модифицировать функцией swap!.

Атрибуты объекта будут хранится как ключевые слова(keywords) а значения - это целые числа.
Методы для сохранения и получения значения атрибутов объекта будут такими:

(defn -setAttr [this attr value]
  (swap! (.state this) assoc attr value))

(defn -getAttr [this attr]
  (get @(.state this) attr))

(defn -removeAttr [this attr]
  (swap! (.state this) dissoc attr))

И маленький пример использования

user=> (def ex (com.Example.))
#'user/ex
user=> (.state ex)
#<Atom@724eb043: {}>
user=> ex
#<Example com.Example@30c06258>
user=> (.setAttr ex :a 1)
nil
user=> (.setAttr ex :b 2)
nil
user=> (.setAttr ex :super-key -9)  
nil
user=> (.state ex)
#<Atom@724eb043: {:super-key -9, :b 2, :a 1}>
user=> (.getAttr ex :b)
2
user=> (.removeAttr ex :super-key)
nil
user=> (.state ex)                
#<Atom@724eb043: {:b 2, :a 1}>

Запуск одного Activity из другого

Алексей — Thu, 28 Apr 2011 09:38:00 +0000

Для того что бы в android приложении запустить одно Activity из другого(например для навигации по интерфейсу приложения) нужно воспользоваться механизмом межпроцессной коммуникации. Для передачи данных между процессами служит объект класса Intent. Для запроса activity, описанного в объекте класса Intent, служат методы startActivity и startActivityForResult.
Существует несколько конструкторов для создания объекта Intent. Если говорить про запуск Activity для решения задач навигации по интерфейсу(собственных интерфейсов), то можно использовать конструктор вида

 public Intent (Context packageContext, Class<?> cls)

с жестким заданием имени класса. Так же для запуска activity понадобится описать в файле AndroidManifest.xml вызываемую activity.

<activity android:name="com.example.MyExampleActivity"
android:label="@string/app_name" />

И запустить activity вызовом метода startActivity.

Код на Java для запроса activity может быть записать так:

this.startActivity(
    new Intent(this, com.example.MyExampleActivity.class)
);

На clojure запуск одной Activity из другой будет таким:

(.startActivity this (Intent. this com.example.MyExampleActivity)

this - текущая activity

Программирование на clojure под android

Алексей — Mon, 18 Apr 2011 05:54:00 +0000

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

зачем: учится новому, получать обратную связь, обсуждать, решать проблемы

о чем: о программировании на clojure под android

Началось все с того что меня заинтересовала разработка под Android. Вслед за этим возник естественный вопрос на чем разрабатывать. От "официальных" языков разработки под android(Java, С++) я был далек и большого желания их изучать и применять не было. Но со времен института остался интерес к функциональным языкам. Особенно к Lisp(на котором я решал исключительно студенческие задачи). Поэтому почитав о Lisp и android побольше я нашел для себя такую связку как clojure + android.
Clojure - функциональный язык программирования, транслируется в Java байт код, имеет глубокую интергацию с ЯП Java. Команда clojure заявляет о поддержке платформы android(точнее dalvik - виртуальной машины andorid). По причинам глубокой интеграции с java и заявлению по поддержке android думаю что clojure станет хорошей альтернативой java на android.

Телеавтоматика.рф

Mon, 09 May 2011 00:00:00 +0000

Весь последний год я занимался всякой херней:

читал русские и заграничные блоги
тупил в Сети
смотрел фильмы
играл в игры
начинал что-то изучать но не заканчивал
немного писал на лиспе, совсем немного на питоне, джаве и аштиэмэле
завел этот блог
добрался до четвертой главы SICP
пытался переписать библиотеку Iterate с Common Lisp'а на Clojure (кодоволкер таки переписал)
досконально изучил пятую главу CTMCP (о конкурентном программировании и передаче сообщений), посмотрел курс лекций UC Berkley CS 61 A и половину курса CS 61 B.

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

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

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

Если раньше я работал 5 часов в месяц, и большую часть оставшегося времени пинал балду, то теперь я работаю с 9ти до 6ти 5 дней в неделю. Ну как сказать работаю… Сейчас я занимаюсь примерно тем же, чем занимался последний год в свободное время: это учеба и программерская практика; но сейчас все серьезней, в больших объемах и с настоящей нагрузкой, не дающей бездельничать и растрачивать свое время попусту. Работа это переход из мира розовых пони и программистов, пишущих на лиспе в эмаксе в суровый российский реал ворлд, которым овладела корпорация зла: начиная с компьютера на котором я пишу по-работе, заканчивая всеми остальными компьютерами в городе (и во всех соседних городах тоже.)

Мои любимые технологии из мира розовых пони проиграли в столкновении с суровой правдой жизни. Линуксу, эмаксу (под виндой он невыносим), лиспу и даже питону (как знать, может быть напишу еще что-нибудь на F#), гиту (на этот счет я все еще теплю надежду покуда SVN в конец не остоп*%дит) и гитхабу (как оплоту всего хорошего в программерском мире) нет места в моем деле.

P.¶.S. Когда через полтора месяца после начала работы дело дошло до документирования проекта, я сдул пыль с «Путеводителя по пакету LaTeX и его расширению LaTeX2ε», поставил TeXlive и NOWEB, открыл Emacs и начал педалить документацию вперемешку с исходниками (знаю, я дурак.) Да, Visio хорош чтобы по-быстрому набросать десяток-другой схемок, но пользоваться Вордом для документирования программ это полный пиздец, тут уж как ни крути.

Я год писал для JVM, но за всю свою жизнь я не написал и десяти классов на джаве. Ближайшие несколько месяцев мне предстоит иметь дело исключительно с Java ME. Первые две недели я пытался организовать под виндой хоть сколько-нибудь рабочее окружение для кодинга для мобильников: перепробовал все 3 среды разработки, посмотрел на богомерзкие средства для кодинга мышкой и взглянул на поражающий воображение своей колоссальностью автосгенерированный Ant-скрипт для сборки проекта. В итоге остановился на варианте Netbeans + Maven + консолька MS PowerShell.

Но кодинг в нашем деле — вещь десятая. Вняв мудрому наставлению, прежде чем написать хоть одну строку я сел за проектирование, черт меня дери. Сидел себе и проектировал, открыв по случаю слайды курса MIT 6.005 Elements of Software Construction. Да, это были две недели дизайна стэйт машин и сетевых протоколов в контексте эргономичного пользовательского интерфейса. Еще две недели неспешного кодирования, и скелет программы готов. Чтобы позже не поиметь головной боли с локами и пятью потоками решил не заморачиваясь с самого начала иметь в виду «Десятое правило Гринспуна»

Любая большая система на C или Java содержит тормозную и бажную реализацию половины Common Lisp.

и наваял самопальную тормозную бажную полу-Эрланг-полу-Кложу.

Что будет дальше не знаю, но работа обещает быть интересной.

Совместное использование Clojure и Java.

Илья Рудаков — Mon, 23 Aug 2010 21:39:00 +0000

В этом посте я на простом примере покажу как соединить в одном проекте Clojure и Java. Сразу к делу...

Создадим проект со следующим деревом каталогов по классическому шаблону для Maven проектов:

В папке src/main/clojure будут храниться исходники Clojure скриптов. В src/main/java - Java классы соответственно. В папку lib помещаем clojure-1.2.0.jar.

Мавеновский pom.xml выглядит следующим образом:


    4.0.0

    test.clojure
    TestClojure
    1.0-SNAPSHOT

    
                    
            
                com.theoryinpractise
                clojure-maven-plugin
                1.1
                
                    
                        src/main/clojure
                    
                    
                        !telchat.app
                    
                    
                
            
        
    

    
        
            org.clojure
            clojure
            1.2.0
        
    

    
        
          clojure-releases
          http://build.clojure.org/releases
        
        
          clojars
          http://clojars.org/repo/

Здесь определены зависимости Clojure версии 1.2.0, указаны репозитории и подключен специальный плагин для компиляции Clojure скриптов.

Теперь давайте немного по-программируем... Для начала определимся со средой для разработки. Лично я привык пользоваться IntellijIDEA. Для написания примера я использовал IntellijIDEA 9.0.3 Community Edition + La Clojure плагин. Данная среда довольно удобная. Clojure скрипты правильно подсвечиваются и даче работает autocomplition. Так же можно запускать REPL прямо из IDE. Хотя вы можете, так же, смело пользоваться Eclipse или, к примеру, Emacs.

Итак, создаем в папке clojure пакет example.clojure.hello и помещаем туда файл Hello.clj.

Далее наполняем Hello.clj следующим содержанием:

(ns example.clojure.hello.Hello
  (:gen-class
    :methods [[sayHello[] void]
               [sayHello[String] void]
               [callFunction[clojure.lang.IFn] String]]))

(defn -sayHello
  ([this] (println "Hello, stranger!"))
  ([this name] (println (str "Hello, " name "!"))))

(defn -callFunction [this javaFunction]
  (javaFunction (str "Vasya" "!")))

Примечание. К сожалению подсветка для Clojure кода в моем блоге не работает. Я думаю, эта проблема решится в ближайшем будущем.

Первой же строчкой в Hello.clj мы видим определение namespace. Это своего рода аналог пакетов в Java. Одна разница, что namespace в Clojure должен оканчиваться именем файла, в котором находятся скрипты. В нашем случае - это Hello.clj и поэтому namespace оканчивается словом Hello.

Далее идет инструкция (:gen-class). Эта инструкция сообщает, что для Hello.clj должен создаваться Hello.class. Для скомпилированного Hello.class автоматически будет создан статический метод main, который вы можете переопределять.

Так же в инструкцию :gen-class входит инструкция :methods. В ней определены Java методы для Hello.class.

(defn -sayHello) и (defn -callFunction) переопределяют поведение будущих методов в Hello.class.

Функция sayHello может принимать от 0 до 1 аргументов. В эту функцию мы будем передавать строку(String) из Java.

Функция callFunction принимает на вход объект типа clojure.lang.IFn. Это интерфейс, который автоматически реализуют все функции в Clojure. Мы же реализуем его вручную в Java, чтобы можно было передавать Java код в Clojure.

Реализуем интерфейс clojure.lang.IFn.

В папке java создадим три класса: Function, MyJavaFunction и Greeting.

Класс Function - абстрактный. Он реализует интерфейс clojure.lang.IFn следующим образом:

import clojure.lang.IFn;
import clojure.lang.ISeq;

public abstract class Function implements IFn {

    @Override
    public Object invoke() throws Exception {
        return doInvoke();
    }

    @Override
    public Object invoke(Object o) throws Exception {
        return doInvoke(o);
    }

    @Override
    public Object invoke(Object o, Object o1) throws Exception {
        return doInvoke(o, o1);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2) throws Exception {
        return doInvoke(o, o1, o2);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3) throws Exception {
        return doInvoke(o, o1, o2, o3);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4) throws Exception {
        return doInvoke(o, o1, o2, o3, o4);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13, Object o14) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13, Object o14, Object o15) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13, Object o14, Object o15, Object o16) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13, Object o14, Object o15, Object o16, Object o17) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16, o17);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13, Object o14, Object o15, Object o16, Object o17, Object o18) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16, o17, o18);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13, Object o14, Object o15, Object o16, Object o17, Object o18, Object o19) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16, o17, o18, o19);
    }

    @Override
    public Object invoke(Object o, Object o1, Object o2, Object o3, Object o4, Object o5, Object o6, Object o7, Object o8, Object o9, Object o10, Object o11, Object o12, Object o13, Object o14, Object o15, Object o16, Object o17, Object o18, Object o19, Object... objects) throws Exception {
        return doInvoke(o, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16, o17, o18, o19, objects);
    }

    @Override
    public Object applyTo(ISeq iSeq) throws Exception {
        return null;
    }

    @Override
    public Object call() throws Exception {
        return doInvoke();
    }

    @Override
    public void run() {
        doInvoke();
    }

    public abstract Object doInvoke(Object... obj);
}

Т.о. мы создали что-то вроде адаптера. Теперь мы можем расширять класс Function и переопределять только один метод doInvoke(...); как показано в примере MyJavaFunction:

public class MyJavaFunction extends Function {

    @Override
    public Object doInvoke(Object... obj) {
        System.out.println("Function call from Java!");
        System.out.println(String.format("Hello, %s", obj[0]));
        return "JAVA FUNCTION WORK SUCCESS!";
    }
    
}

Отлично. Теперь собираем все воедино в классе Greeting:

import example.clojure.hello.Hello;

public class Greeting {

    public static void main(String[] args) {
        Hello hello = new Hello();
        if(args.length == 0) {
            hello.sayHello();
        } else {
            hello.sayHello(args[0]);
        }

        Function fun = new MyJavaFunction();
        String result = hello.callFunction(fun);
        System.out.println(result);
    }
}

Итак, перед сборкой и запуском несколько комментариев. В Greeting мы создаем объект типа Hello из Clojure namespace example.clojure.hello.Hello и вызываем функцию sayHello. Далее мы создаем объект типа Function и передаем его в Clojure функцию callFunction и выводим на экран вернувшийся результат.

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

mvn clean clojure:compile install

Чтобы запустить класс Greeting нужно выполнить команду:

java -cp target/TestClojure-1.0-SNAPSHOT.jar:lib/clojure-1.2.0.jar Greeting

или

java -cp target/TestClojure-1.0-SNAPSHOT.jar:lib/clojure-1.2.0.jar Greeting Vasya

(Я запускал под Linux. Символ разделения ':' в Windows другой - ';')

После выполнения вы должны увидеть что-то наподобие такого:

Hello, stranger!
Function call from Java!
Hello, Vasya!
JAVA FUNCTION WORK SUCCESS!

Clojure

Fri, 10 Sep 2010 23:41:53 +0000

(может быть интересно только для программистов)

Было несколько дней поиграть с Clojure.
Мои впечатления:

Положительные:

1) REPL. Самый полезный REPL из всех, которыми я когда-либо пользовался. По-настоящему интерактивная разработка. Написал (прямо в REPLе) - протестировал, после того, как работает - скопировал в нормальный файл. Я довольно много пользовался REPL в нескольких других языках (Forth, Python, Erlang) - но почти исключительно для экспериментиров, не для нормальной разработки. За счет особенностей языка в Clojure REPL превращается в полноценный инструмент разработки.

2) Очень помогает, что maps и sets - first-class objects, со своим синтаксисом. Также, квадратные скобки для векторов - мне очень это помогает. Я всегда уважал идеологию Лиспа - everything is a list, но для практического программирования, думаю, нужны "зацепки", как визуальные приправы к коду. Примерно как засечки в serif-шрифтах - они делают код более читабельным.

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

4) К моей радости, получается почти не использовать рекурсию в тех случах, когда явно она не нужна. Чтобы объяснить, что я имею в виду под нужной и ненужной, надуманной рекурсией. Нужная рекурсия - например, в каком-то алгориме обхода дерева. Или в алгоритме quicksort. Потому что сам алгоритм определяется в терминах рекурсии. Надуманная рекурсия - это, например, имплементация факториала как x * f(x-1). Факториал определен как 1 * 2 * 3 * ... * N, поэтому "правильно" его имплементировать с помощью функции reduce.
Или, например, еще пример "неправильной рекурсии": когда нужно N раз что-то сделать, использовать tail-recursion со счетчиком N. Нет, правильная имплементация - это, например, в Руби: N.times do ....

5) Вся идея persistent data structures - очень здоровая.

Отрицательные:

1) Изо всех щелей лезет Джава. Я понимаю все преимущества, которые мы получаем for free вместе с JVM, но все равно, на мой вкус, нужно слишком много знать о Джаве, чтобы писать на Clojure. Я к ней не прикасался уже 5 лет, но, похоже, придется.

2) Язык динамический, поэтому компилятор помогает очень мало, а сообщения о run-time ошибках - совершенно неинформативные, ничего понять по ним невозможно (мне, по крайней мере). В результате - идею алгоритма я описал в Clojure коде за день, очень компактно - на страничку (на С++ заняло бы на порядок больше). Пока не запустил, находился в эйфории....Но теперь уже 3 дня не могу этот код отладить. В общем, делаю гораздо больше ошибок, чем в Haskell-коде (там, правда, другая история - скомпилировать невозможно, пока все ошибки не найдешь, зато в run-time - все магически работает с первого раза). И даже в Erlang - хотя он тоже динамический. И ошибок делал меньше, и находил их гораздо быстрее. Не знаю, почему. Возможно, потому что Erlang проще как язык и встроенных возможностей меньше. Ну и pattern matching в Erlang очень помогает - хотя ошибка происходит в runtime, но сразу понятно, в каком месте, что конкретно неcmatchилось.

3) Документация хуже чем у всех последних языков, которые я изучал. Онлайн-документация мне не нравится - и поиск по ней организован плохо, и объяснения не всегда достаточные. Книги у меня уже все три (Practical Clojure < Programming Clojure << Joy of Clojure), но ни одна из них не работает в качестве reference.

4) Легкий дискомфорт оттого, что nil и пустой список - это разные вещи. Например, функции типа get или nth работают совсем по-разному на nil и пустых структурах данных. И еще один уровень сложности - булевы переменные, что считается true и что - нет. В общем, я понимаю, это дает больше flexibility, но мне больше нравился чистый подход Erlang, когда нет никаких "специальных" вещей типа nil, и даже булевых переменных нет. Паттерн матчинг - и вперед; true - это просто атом. Но это уже так, "вкусовщина".

5) Идея о том, что любые коллекции могут притворяться sequence, с одной стороны, хороша. С другой стороны, там под низом все равно сидит конкретная структура данных, и что во что преобразовывается - не всегда понятно. Точнее, понятно, описано, но - неинтуитивно как-то. И не только в случах с sequence. Например, к записи (в смысле defrecord) можно добавить поле в рантайм, как к обычной hash map, от этого она не перестает быть записью. Но если удалить поле, то она превращается в map. Запомнить несложно. Но в языке как-то уж очень много таких "специальных правил". С другой стороны, Perl я люблю, несмотря на количество специальных правил, как родного уродца. Так что, может, и тут постепенно "сроднюсь".

Если взвесить за и против, положительные впечатления значительно перевешивают. Единственная реальная проблема - (2), c малополезными сообщениями об ошибках. Надеюсь улучшить навыки отладки со временем.

Да, еще пару слов о среде разработки. Лучше всего работало - просто REPL в командной строке и открытый файл в vi, в другом окне. За тем исключением, что REPL не имеет истории (или я не нашел, как ей пользоваться).
Пробовал установить plug-in к Eclipse. Почти все хорошо, но раздражает то, что я не могу понять его логики. Иногда мне достаточно сохранить .clj-файл, чтобы в REPL в консоли увидел все изменения. А иногда - нет, нужно явно выделять и копировать из редактора в REPL. А вчера начал разбираться с defrecord - вообще отакзывалось принимать новые определения записи с тем же именем, пришлось перезапустить Eclipse.
Посмотрю еще на VimClojure.

В общем, пока что, Clojure - это очень интересно!

Game of Life and Clojure

Wed, 25 Aug 2010 07:39:53 +0000

(это продолжение прошлой заметки о программировании на Closure)

Итак, игра Жизнь.

Идея имплементации такая. Популяция описывается массивом позиций занятых клеток. Каждая позиция - это просто пара [x,y].
Дальше для каждой отдельно выбранной занятой позиции [x,y] строим таблицу координата -> значение, где координаты - это cоседи клетки [x, y] и она сама. Для соседей значение = 1, для самой клетки - значение = 10.
Потом "складываем" все таблицы для всех клеток популяции. В полученной таблице живые клетки следующей популяции будут равны 3 (новорожденные) или 12 или 13 (старые клетки, которые имели одного или двух соседей). Фильтруем таблицу по значениям и берем ее ключи - это и есть следующее поколение популяции.

На языке Clojure это будет выражаться так (не пинать больно, я только на прошлой неделе стал изучать Closure):

Относительные координаты 8 соседей каждой клетки:

(def nbr-deltas [[-1 -1][-1 0][-1 1][0 -1][0 1][1 -1][1 0][1 1]])

Функция, которая расчитывает координаты соседей клетки [x y]:

(defn nbr-cells [[x y]] (map (fn [[a b]] [(+ x a)(+ y b)]) nbr-deltas))

Таблица значений для одной клетки cell (cell - то же самое, что [x y]):

(defn cell-table [cell] (apply conj {cell 10} (map #(vec [% 1]) (nbr-cells cell))))

Складываем все таблицы для популяции cells:

(defn all-table [cells] (apply merge-with + (map cell-table cells)))

Все, осталось только отфильтровать эту таблицу по значениям и взять ее ключи:

(defn next-gen [cells] (keys (filter #(#{3 12 13} (second %)) (all-table cells))))

Функция next-gen берет на входе популяцию и возвращает следующее состояние популяции.
Готово! Для имплементации правил понадобилось всего 4 функции - красота!

Чтобы расчитать на n поколений вперед, используем цикл (ну, через рекурсию):

(defn n-next-gen [n cells] (if (== n 0) cells (recur (- n 1) (next-gen cells))))

(Наверное, это можно было изящнее записать, с помощью loop, но я пока не разобрался как).

Для тестирования хорошо использовать одну из первых "трудных" популяций Жизни: r-пентамино:

(def r-pentomino [[0 1][1 1][2 1][1 2][2 0]])

Как известно, эволюция этой популяции стабилизируется только на 1103 поколении, и она с этого момента насчитывает 116 клеток.
Проверяем:

(count (n-next-gen 1103 r-pentomino))
116

Ура! Все работает. Расчет занял 12 секунд на МacBook Pro (2.53 GHz Intel Core 2 Duo, 4GB RAM), то есть около 100 поколений в секунду.
Теперь интересно попробовать поизменять детали имплементации и посмотреть, как это влияет на производительность.

В имплеменации только одна деталь, специфическая для Clojure - функция merge-with. Если забыть об этой детали, имплементацию можно без проблем портировать на другие языки. Что я и попробую сделать - интересно, как это будет выглядеть и как быстро будет считаться. Вместо merge-with нужно будет что-то придумать, в зависимости от возможностей языка.

Ну и, конечно, следующий шаг - нужно сделать простенький GUI.

Clojure

Tue, 24 Aug 2010 21:25:13 +0000

(запись может быть интересна только программистам)
Какое-то время я следовал правилу - в год изучать по языку. Так "прошел" Haskell, D, Lua, Erlang. Сейчас взялся за Clojure.

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

Ниже - первые впечатления о Clojure и связанные вопросы.

В языке много неортогональностей. Одно и то же можно делать разными способами, что, в-общем, мне нравится (TIMTOWTDI, Perl мне нравится больше Python). Но хорошо понимать trade-offs и зачем в принципе включены разные возможности. Например, в Erlang мне очень понравились атомы - это то, что в некоторых других языках называют еще символами. Просто слова, которые означают самих себя. В Erlang даже нет отдельного булевского типа, true и false - это просто атомы. В сочетании с pattern matching атомы очень-очень удобны. В Closure есть символы... но есть и keywords. Зачем нужны keywords, если вместно них можно использовать symbols? В книге об этом ничего не говорится, или я пропустил.

Дальше, векторы и списки. Когда что использовать? Если нужно быстрый nth, то, понятно - вектор. Если добавлять что-то в голову - наверное, список. Но что, если мне нужен просто маленький tuple, скажем, просто пара значений? Отдельного типа данных tuple нет. Что лучше - список или вектор? или вообще что-то другое? и в каком смысле лучше - скорость, память? Как-то про это тоже ничего в книге не нашел.

Теперь pattern matching. Это понятие вообще в книге не упоминается, и в языке нет такого продвинутого pattern matching-а, как в Haskell или Erlang.
Но тем не менее, я могу определить функцию как
(defn f [[x y] z] (+ x y z))
и она будет ожидать два аргумента, первый из которых - вектор, и сразу bind-ить его элементы как x и y. То есть вызвать ее можно будет как (f [1 2] 3)
Но оказывается - не обязательно вектор. Можно вызвать функцию и так: (f '(1 2) 3)
А вот так не работает: (f 1 2) - выбрасывает эксепшн, что к типу Integer нельзя применить операцию nth. Ага. Значит никакого matching-а типов не делается, просто к типу применяется операция nth. Интересно, можно ли туда передать еще что-нибудь, что откликается на nth? Что? Все это как-то путем проб и ошибок, а, казалось правила binding должны быть высечены в камне... в книге как-то я вообще об этом ничего не было... или я пропустил?

Дальше еще одно. В философии языка все время делается упор на immutable data, чистое функциональное программирование,где все side effects четко выделены. Хорошо, но почему я тогда могу спокойно переопределить переменную? И, главное, все функции, которые ее видели при определении, ведут себя не как closure. Вместо того, чтобы запомнить ее значение на момент создания, они используют ее текущее значение на момент вызова.
Например,

(def pi 3.14)
(defn area [r] (* pi r r))
(area 1)
3.14
(def pi 3)
(area 1)
3

Ну и в чем тогда отличие от глобальных переменных в императивных языках программирования?

Дальше, STM - тут все очень интересно и классно. Целых 3 разных инструмента - refs, atoms, agents. Пока что я просто не понимаю, когда и как все это использовать, но думаю, с практикой это придет. Вначале я подумал, что agents - это то же самое, что процессы в Erlang, но, оказалось, увы, не совсем. Но все равно, STM и persistent data structures - это все очень интересно. На C++ ный multithreaded код мне уже давно страшно смотреть. А приходится.

Да, теперь интересно найти какую-то GUI или graphics бибилиотеку для Clojure, чтобы поэкспериментировать. Я попробовал написать игру "жизнь", и к моему удивлению это очень просто получилось, вся имплементация на Clojure заняла 10 строчек и все заработало с первого раза. Это хороший знак, у меня так было только с Haskell-ем, чтобы что-то с первого же раза работало as intended. Но красивого вывода на экран нет - а хочется. Как я понял, clojure-народ пользуется для GUI жавским Swing-ом. Как-то неохота его изучать, не знаю, есть ли другие удобные способы.

А в общем - очень интересный язык! Сегодня попробую поиграть с мультиметодами.

P.S. Описал свою имплементацию Жизни в следующей заметке.

Разговор со спикерами FPConf (часть 2)

elena_voronina — Fri, 14 Aug 2015 06:34:09 +0000

Привет!

Конференция FPConf уже завтра, сегодня последний шанс купить билет и присоединиться! Регистрация — тут.

Накануне мы решили задать нашим спикерам один довольно неоднозначный вопрос. Большая часть ответов была опубликована вчера — тут

А сегодня мы получили ответ от нашего гостя Эдварда Кметта. Пока публикуем без перевода, обновим пост после конференции.

Вопрос был такой:

В объектно-ориентированных языках есть широко известный список паттернов проектирования (design patterns) от «Банды четырех» (Gang of Four). В функциональных языках такого известного списка не существует. С вашей точки зрения, почему так?
Подобные паттерны не нужны при программировании на функциональных языках или просто их канонический список еще не сложился?

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

Разговор со спикерами FPConf

elena_voronina — Thu, 13 Aug 2015 13:04:31 +0000

Привет!

Конференция FPConf уже в эту субботу, нас аж 160 и еще не поздно заскочить в последний вагон. Регистрация — тут.

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

В объектно-ориентированных языках есть широко известный список паттернов проектирования (design patterns) от «Банды четырех» (Gang of Four). В функциональных языках такого известного списка не существует. С вашей точки зрения, почему так?
Подобные паттерны не нужны при программировании на функциональных языках или просто их канонический список еще не сложился?

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

Russian Clojure Planet

Готовится перевод "Clojure Programming"

Выступление про Clojure на ITSea 2012

Clojure 1.4!

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

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

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

Reflection API

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

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

Прочее

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

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

DSLs in Action

Camel in Action

Test-driven development: By Example

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

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

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

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

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

deftype & defrecord

reify

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

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

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

The Joy of Clojure: Thinking the Clojure Way

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

Introduction to Algorithms

Вторая часть марлезонского балета

Вышла Clojure 1.2

Подкастовое

Русская планета Clojure

Деструктуризация параметров в Clojure

Статья про Clojure & Hadoop

Список рассылки про Clojure на русском

Презентация про Clojure с MarginCon 2010

Впечатления о Practical Clojure

Небольшой опрос

Видео-материалы про Clojure (продолжение)

Leiningen + Clojure

Использование Maven для сборки кода на Clojure

Более простое начало работы с Clojure

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

Презентация про Incanter

Видеоматериалы про Clojure

Applicative-order evaluation vs Normal-order evaluation

FP-approach in Java via Goolge Collections

Задачка: A(4,3)

Задачка: Робот на бесконечной лестнице

Clojure - Hello world!

Devclub 2011 # 02. Про лисп.

Волшебство и Магия Clojure

devclub.eu quiz

Clojure video [devclub.eu #04-10]

Clojure тренинг!

А в это время в рунете про Clojure (06 февраля -> 13 марта 2010)

А в это время в рунете про Clojure (24 января -> 05 февраля 2010)

clojure in action

3 HelloWorld на Clojure

Clojure в рунете (18 -> 23 января 2009)

Clojure in Action for 10$

clojure epic fail

Clojure ratio

DSLs in Action

FUD Scala vs Clojure!

Вариант на Scala

Вариант на Clojure

кинул бы в твиттер, но вышел за пределы :)

Мысли вслух. Как рассматривать Clojure в контексте хотя бы лет 5?

требуется Clojure Middle back-end developer в Москву

Бонусы

Вакансия: Новосибирск, Java/Scala/Clojure-разработчик (платформа Eclipse), в офис, 110 000 р.

j2me и ClassLoader в clojure

seq в vector

letrec

Волшебство и Магия Clojure

clojure conference

lafy: Clojure video [devclub.eu #04-10]

mock и stub в clojure

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

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