среда, 15 декабря 2010 г.

Книга Криса Смита «Программирование на языке F#»

ProgrammingFSharp

Любая методология разработки, инструмент, технология или язык программирования привлекает к себе внимание по разным причинам. Это может быть нечто инновационное и тогда по прошествию десятка или двух лет (!), до него таки дотянутся руки всего остального компьютерного сообщества. Так было практически со всеми идеями, которым пришлось пройти длительный путь от конференций гиков до признания широкой общественностью. Другим способом ворваться в «мейнстрим» является поддержка уже известного вендора, например такого, как компания … Майкрософт. Большинство людей инерционны и не будут вкладывать свои силы в «нонейм» инструменты, пока не удостоверятся, что их капиталовложение будет востребовано. Если же инструментом занимается подобный вендор, то риск изучить что-то, что не пригодится в будущем, очень не велик.

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

понедельник, 13 декабря 2010 г.

Microsoft Moles

Moles – это легковесный тул от MS Research, который умеет автоматически генерировать заглушки для интерфейсов и виртуальных методов, а также для sealed классов, невиртуальных и статических методов (!), путем генерации кода, которому позднее можно будет подсунуть нужный делегат, вызываемый вместо определенного метода. Первый тип заглушек называется стабы (stubs), а второй – молы (moles). Именно эту штуку я использовал для тестирования асинхронных операций, о которых я рассказывал ранее, но давайте обо всем по порядку.

Stubs

Давайте рассмотрим такой пример. Предположим, что мы понимаем ценность модульных тестов, а также таких принципов, как Dependency Inversion, и других безумно полезных принципов и паттернов (может быть всех остальных принципов S.O.L.I.D., а возможно даже и F.I.R.S.T.). И дело даже не в том, что мы фанаты тестов или дядюшки Боба, а просто потому, что мы знаем, что высокая связность – это плохо. Поэтому мы стараемся в разумных пределах уменьшить зависимости путем выделения интерфейсов с последующим «инжектом» их в конструкторы классов или в методы, которым эти интерфейсы необходимы для выполнения своих задач.

четверг, 2 декабря 2010 г.

Знакомство с асинхронными операциями в C# 5

В прошлый раз мы говорили о том, как можно упростить работу с асинхронными операциями с помощью класса AsyncEnumerator Джеффри Рихтера, а также с помощью библиотеки Reactive Extensions. Однако, как поведал нам недавно Хейлсберг с компанией, счастье таки наступит с выходом новой версии языка C# и нам не понадобится использовать сторонние и не очень велосипеды, при работе с асинхронными операциями.

Идея, которая лежит в основе асинхронных операций в C# 5, очень похожа на ту, которую использовал Джеффри Рихтер в своем классе AsyncEnumerator, только на этот раз помимо нас с вами и старины Рихтера о ней еще узнал и компилятор (что здорово сказывается на вкусовых качествах сего синтаксического сахарка).  Для начала, давайте вернемся к синхронной версии нашего гениального примера, который мы использовали ранее:

static void SyncVersion()
{
    Stopwatch sw = Stopwatch.StartNew();
    string url1 = "http://rsdn.ru";
    string url2 = "http://gotdotnet.ru";
    string url3 = "http://blogs.msdn.com";
    var webRequest1 = WebRequest.Create(url1);
    var webResponse1 = webRequest1.GetResponse();
    Console.WriteLine("{0} : {1}, elapsed {2}ms", url1,
        webResponse1.ContentLength, sw.ElapsedMilliseconds);

    var webRequest2 = WebRequest.Create(url2);
    var webResponse2 = webRequest2.GetResponse();
    Console.WriteLine("{0} : {1}, elapsed {2}ms", url2,
        webResponse2.ContentLength, sw.ElapsedMilliseconds);

    var webRequest3 = WebRequest.Create(url3);
    var webResponse3 = webRequest3.GetResponse();
    Console.WriteLine("{0} : {1}, elapsed {2}ms", url3,
        webResponse3.ContentLength, sw.ElapsedMilliseconds);
}

четверг, 25 ноября 2010 г.

“Реактивные расширения” и асинхронные операции

  • Прежде чем переходить непосредственно к работе с асинхронными операциями с помощью библиотеки Reactive Extensions (или Rx), важно понять причины возникновения этой библиотеки, и какие основные принципы положили разработчики в ее основу.

    Одним из наиболее типичных отношений между двумя классами является отношение использования (“uses a” relationship), когда один класс используют функциональность других классов для решения своих задач. Мы с подобным отношением сталкиваемся ежедневно, даже не задумываясь о нем: наши классы используют строки, целые числа, классы работы с консолью, сетью, файлами и другими ресурсами. Говорят, что объект класса A взаимодействует (interact) с объектом класса B и получает (вытягивает, pulls) у него необходимые данные; такая модель взаимодействия называется pull-моделью (или интерактивной моделью) (рисунок 1а). С другой стороны, часто возникает ситуация, когда объект класса A не знает, когда будут доступны необходимые ему данные в классе B, и в таком случае гораздо удобнее, чтобы объект класса B «сказал» об этом самостоятельно и «вытолкнул» (push) некоторые данные, когда они станут доступны. В этом случае говорят, что объект класса А реагируют (react) на возникшие событие и соответствующая модель называется push-моделью или реактивной моделью (рисунок 1б) [Meijer RX1].

     Rx1
    Рисунок 1а. Класс A взаимодействует с классом B

     Rx2
    Рисунок 1б. Класс A реагирует на события от класса B

    среда, 3 ноября 2010 г.

    Pragmatic Podcast с Робертом Мартином

    Pragmatic PodcastsУ меня неоднозначное отношение к техническим подкастам. С одной стороны, если вы хорошо знакомы с темой, то вы вряд ли узнаете много нового, а если тема для вас нова, то, познакомиться с ней нормально за час аудиоматериала весьма сложно. Кроме того, далеко не каждую тему из области разработки ПО возможно описать без примеров кода, диаграмм и рисунков. Но тем не менее, время от времени попадаются достаточно интересные подкасты, в которых рассказывается о новинках в той или иной области, или проводится интервью с интересным и, зачастую, известными товарищами, которые даже в столь жестких рамках умудряются поведать много чего интересного.

    Вот и мне совсем недавно попался “прагматичный” подкаст с Робертом Мартином, "товарищем" достаточно известным, автором принципов S.O.L.I.D. (точнее этой аббревиатуры), нескольких книг, ну и вообще человеком с более чем сорокалетним стажем в нашей с вами области. Поскольку немалая толика этой известности приходится именно на аббревиатуру S.O.L.I.D. не удивительно, что в каждом интервью с участием "дядюшки" Боба ему задается этот вопрос. Но в данном случае мой интерес вызвало не то, что Роберт все таки помнит об этих принципах, а то, что этим принципам уже без малого 20 лет. По словам Роберта этот термин появился где-то в 1993 году в результате общения в USENET. Получается, что самому понятию понадобилось без малого десятилетие на то, чтобы обрести известность.

    воскресенье, 24 октября 2010 г.

    Асинхронные операции и AsyncEnumerator

  • Все знают, что синхронное выполнение длительных операций – это плохо. Это плохо по многим причинам, начиная с того, что синхронные решения приводят к подвисанию пользовательского интерфейса, плохой масштабируемости и расширяемости, заканчивая тем, что вы не сможете воспользоваться всеми возможностями многоядерного процессора даже вашего домашнего компьютера, не говоря уже за преимущества асинхронного ввода/вывода, эффективность которого проявляется даже на одноядерных машинах. О теме асинхронности и многопоточности говорят на каждом шагу, начиная от небезызвестных товарищей вроде Джеффри Рихтера, Джо Даффи или Джозефа Албахари, заканчивая множеством статей на каждом втором техническом сайте и обязательным вопросом на собеседовании типа «А сколько вы знаете способов выполнить операцию асинхронно?».

    Авторы книг и статей, любят эту тему, потому что она обширная и сложная, да в последнее время еще и модная. Интервьюеры же любят ее за то, что вариантов ответа на этот вопрос в контексте платформы .Net много, и у каждого интервьюера может быть свой любимый способ доказать соискателю, что тот чего-то все же не знает. С точки зрения простого программиста использование всех современных инструментов для работы с многопоточностью, несмотря на все обещания их разработчиков, все еще остается делом непростым и легко может привести к вывиху мозга, а малейшая неосторожность – к отстрелу нескольких ценных конечностей. Одной из причин, почему так происходит, является то, что вся поддержка многопоточности в языке C# заканчивается оператором lock, а все остальное прикручено к нему благодаря сторонним (или не очень) библиотекам, начиная с BCL и RX, заканчивая PowerThreading и другими велосипедами, различного вида и формы (хотя, конечно же, главная причина заключается в том, что тема, эта сама по себе, не просто сложная, а очень сложная, и все попытки ее упростить настолько, чтобы она была понятна домохозяйкам, успехом не увенчалась, и едва ли увенчается когда-либо).

    Я же никакие свои велосипеды изобретать не собираюсь, а сосредоточусь лишь на различных способах работы с асинхронной моделью программирования (AsynchronousProgrammingModel, APM) на платформе .Net на примере идеи, предложенной Джеффри Рихтером с его классом AsyncEnumerator.

    понедельник, 27 сентября 2010 г.

    [Перевод] Джозеф Албахари. Часть 5.2. Параллельное программирование

    Это перевод второй (и заключительной) части статьи Джозефа Албахари (Joseph Albahari) о работе с потоками в C# - “Part 5: Parallel Programming”.

    Распараллеливание агрегатных функций

    PLINQ эффективно распараллеливает такие операторы как Sum, Average, Min и Max без дополнительного вмешательства. Оператор Aggregate предоставляет особые дополнительные возможности в PLINQ.

    Если вы не знакомы с этим оператором, вы можете рассматривать его как обобщенную версию операторов Sum, Average, Min и Max, другими словами, это оператор, который позволяет добавить вам специализированный алгоритм аккумулирования (accumulation) значений для реализации нетиповых агрегаций.

    int[] numbers = { 1, 2, 3 };
    int sum = numbers.Aggregate (0, (total, n) => total + n);   // 6

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

    ПРИМЕЧАНИЕ
    Большинство задач, для которых предназначен метод Aggregate, могут быть легко решены с помощью более знакомого синтаксиса – цикла foreach. Преимущество использования Aggregate заключается в том, что большая и сложная агрегация может быть распараллелена декларативным образом.