<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[tech.sbermarket.blog - Medium]]></title>
        <description><![CDATA[Кодим будущее доставки товаров - Medium]]></description>
        <link>https://medium.com/tech-sbermarket-blog?source=rss----6cc8f7d7d78c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>tech.sbermarket.blog - Medium</title>
            <link>https://medium.com/tech-sbermarket-blog?source=rss----6cc8f7d7d78c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 03:26:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/tech-sbermarket-blog" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[GoF on Ruby # 3]]></title>
            <link>https://medium.com/tech-sbermarket-blog/gof-on-ruby-3-386bda4ae328?source=rss----6cc8f7d7d78c---4</link>
            <guid isPermaLink="false">https://medium.com/p/386bda4ae328</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[fog]]></category>
            <category><![CDATA[patterns]]></category>
            <category><![CDATA[ruby]]></category>
            <dc:creator><![CDATA[Paul  Yakshankin]]></dc:creator>
            <pubDate>Sun, 31 Mar 2019 21:52:10 GMT</pubDate>
            <atom:updated>2019-11-07T09:52:45.737Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ReAQ-d-2jbhCiSe-65diQ.png" /></figure><p>Привет, сегодня мы заканчиваем говорить о паттернах проектирования: в <a href="https://medium.com/tech-instamart-blog/gof-on-ruby-2-e326a7b0d209">прошлый раз</a> мы рассмотрели структурные паттерны, теперь пришло время паттернов поведения.</p><p><em>Напоминаю: все примеры кода абстрактные, и призваны лишь выразить общую идею реализации паттерна.</em></p><h3>Паттерны поведения</h3><p>Паттерны поведения связаны с алгоритмами и распределением обязанностей между объектами. Речь в них идет не только о самих объектах и классах, но и о типичных способах взаимодействия. Паттерны поведения характеризуют сложный поток управления, который трудно проследить во время выполнения программы.</p><h4>Chain of Responsibility</h4><p>Позволяет избежать привязки отправителя запроса к его получателю, давая шанс обработать запрос нескольким объектам. Связывает объекты получатели в цепочку и передает запрос вдоль этой цепочки, пока его не обработают.</p><p><strong><em>Применимость</em></strong></p><ul><li>есть более одного объекта, способного обработать запрос, причем настоящий обработчик заранее неизвестен и должен быть найден автоматически;</li><li>вы хотите отправить запрос одному из нескольких объектов, не указывая какому именно;</li><li>набор объектов, способных обработать запрос, должен задаваться динамически.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Handler - определяет интерфейс для обработки запросов, реализует связь с преемником;</li><li>Concrete Handler - обрабатывает запрос за который отвечает;</li><li>Client - отправляет запрос некоторому объекту Concrete Handler в цепочке.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/208b8304cff3f8ead8491963f8279939/href">https://medium.com/media/208b8304cff3f8ead8491963f8279939/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>ослабление связанности;</li><li>дополнительная гибкость при распределении обязанностей между объектами.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>получение не гарантировано.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Command</h4><p>Инкапсулирует запрос как объект, позволяя тем самым задавать параметры клиентов для обработки соответствующих запросов, ставить запросы в очередь или протоколировать их, а также поддерживать отмену операций.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо параметризовать объекты выполняемым действием;</li><li>нужно определять, ставить в очередь и выполнять запросы в разное время;</li><li>вы хотите поддержать отмену операций;</li><li>нужно поддержать протоколирование изменений;</li><li>необходимо структурировать систему на основе высокоуровневых операций, построенных из примитивных.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Command - объявляет интерфейс для выполнения операции;</li><li>Concrete Command - определяет связь между Receiver и действием, реализует операцию Execute путем вызова соответствующих операций объекта Receiver;</li><li>Client - создает объект класса Concrete Command и устанавливает его получателя;</li><li>Invoker - обращается к команде для выполнения запуска;</li><li>Receiver - располагает информацией о способах выполнения операций, необходимых для удовлетворения запроса.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/91fbf08054afa4810971de3734c94872/href">https://medium.com/media/91fbf08054afa4810971de3734c94872/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>убирает прямую зависимость между объектами, вызывающими операции, и объектами, которые их непосредственно выполняют;</li><li>позволяет реализовать простую отмену и повтор операций;</li><li>позволяет реализовать отложенный запуск операций;</li><li>позволяет собирать сложные команды из простых.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>усложняет код программы из-за введения множества дополнительных классов.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Interpreter</h4><p>Для заданного языка определяет представление его грамматики, а также интерпретатор предложений этого языка.</p><p><strong><em>Применимость</em></strong></p><ul><li>грамматика проста;</li><li>эффективность не является главным критерием.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Abstract Expression - объявляет абстрактную операцию Interpret, общую для всех узлов в абстрактном синтаксическом дереве;</li><li>Terminal Expression - реализует операцию Interpret для терминальных символов грамматики, необходим отдельный экземпляр для каждого терминального символа в предложении;</li><li>NonTerminal Expression - реализует операцию Interpret для нетерминальных символов грамматики;</li><li>Context - содержит информацию, глобальную по отношению к интерпретатору;</li><li>Client - вызывает функцию Interpret, строит абстрактное синтаксическое дерево, представляющее отдельное предложение на языке с данной грамматикой. Составлено дерево из экземпляров Terminal Expression и NonTerminal Expression.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37447c85f6d9e1ed601e9d20e9add8d2/href">https://medium.com/media/37447c85f6d9e1ed601e9d20e9add8d2/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>грамматику легко изменять и расширять;</li><li>простая реализация грамматики.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>сложные грамматики трудно сопровождать.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Iterator</h4><p>Предоставляет способ последовательного доступа ко всем элементам составного объекта, не раскрывая его внутреннего представления.</p><p><strong><em>Применимость</em></strong></p><ul><li>для доступа к содержимому агрегированных объектов без раскрытия их внутреннего представления;</li><li>для поддержки нескольких активных обходов одного и того же агрегированного объекта;</li><li>для предоставления единообразного интерфейса с целью обхода различных агрегированных структур.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Iterator - определяет интерфейс для доступа и обхода элементов;</li><li>Concrete Iterator - реализует интерфейс класса Iterator, следит за текущей позицией;</li><li>Aggregate - определяет интерфейс для создания объекта-итератора;</li><li>Concrete Aggregate - реализует интерфейс создания итератора и возвращает экземпляр подходящего класса Concrete Iterator.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/270c7f44f50e8ba9299b23c343854603/href">https://medium.com/media/270c7f44f50e8ba9299b23c343854603/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>упрощает классы хранения данных;</li><li>позволяет реализовать различные способы обхода структуры данных;</li><li>позволяет перемещаться по структуре данных в разные стороны.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>не оправдан если можно обойтись простым циклом.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Mediator</h4><p>Определяет объект, инкапсулирующий способ взаимодействия множества объектов. Обеспечивает слабую связанность системы, избавляя объекты от необходимости явно ссылаться друг на друга.</p><p><strong><em>Применимость</em></strong></p><ul><li>имеются объекты связи между которыми сложны и четко определены;</li><li>нельзя повторно использовать объект, так как он обменивается связями со многими объектами;</li><li>поведение, распределенное между классами должно поддаваться настройке без порождения множества классов.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Mediator - определяет интерфейс для обмена информацией с объектами Colleague;</li><li>Concrete Mediator - реализует кооперативное поведение, координируя действия объектов Colleague;</li><li>Colleague - каждый такой класс знает о своем Mediator, все коллеги обмениваются информацией только с посредником.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f72c56912402fd8c8be359da9501918b/href">https://medium.com/media/f72c56912402fd8c8be359da9501918b/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>снижает число порождаемых классов;</li><li>устраняет связанность между коллегами;</li><li>упрощает протоколы взаимодействия объектов;</li><li>абстрагирует способ кооперирования объектов.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>централизует управление.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Memento</h4><p>Не нарушая инкапсуляции, фиксирует и выносит за пределы объекта его внутреннее состояние так, чтобы позднее можно было восстановить в нем объект.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо сохранить мгновенный снимок состояния объекта, чтобы впоследствии объект можно было восстановить в том же состоянии;</li><li>прямое получение этого состояния раскрывает детали реализации и нарушает инкапсуляцию объекта.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Memento - сохраняет внутреннее состояние объекта Originator, запрещает доступ всем другим объектам, кроме хозяина;</li><li>Originator - создает хранитель, содержащий снимок текущего внутреннего состояния, использует хранитель для восстановления;</li><li>Caretaker - отвечает за сохранение хранителя, не производит никаких операций над хранителем и не исследует внутреннее содержимое.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1a794bc553fc223b4036f14b5ed163d6/href">https://medium.com/media/1a794bc553fc223b4036f14b5ed163d6/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>сохранение границ инкапсуляции;</li><li>упрощение структуры хозяина.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>значительные издержки при использовании хранителей;</li><li>скрытая плата за содержимое хранителя.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Observer</h4><p>Определяет зависимость “один ко многим” между объектами таким образом, что при изменении состояния одного объекта все зависящие от него оповещаются об этом.</p><p><strong><em>Применимость</em></strong></p><ul><li>у абстракции есть два аспекта, один из которых зависит от другого;</li><li>при модификации одного объекта нужно изменить другие и вы не знаете, сколько объектов нужно изменить;</li><li>когда один объект должен оповещать других, не делая предположений об уведомляемых объектах.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Subject - располагает информацией о своих наблюдателях, предоставляет интерфейс для присоединения и отделения наблюдателей;</li><li>Observer - определяет интерфейс обновления для объектов, которые должны быть уведомлены об изменении субъекта;</li><li>Concrete Subject - сохраняет состояние, представляющее интерес для конкретного наблюдателя, посылает информацию своим наблюдателям об изменении;</li><li>Concrete Observer - хранит ссылку на объект класса Concrete Subject, сохраняет данные, которые должны быть согласованы с данными субъекта, реализует интерфейс обновления, определенный в классе Observer, чтобы поддерживать согласованность с субъектом.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f2e88ec0dfb2e060effd7ad70da4a4f4/href">https://medium.com/media/f2e88ec0dfb2e060effd7ad70da4a4f4/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>абстрактная связанность субъекта и наблюдателя;</li><li>поддержка широковещательных коммуникаций.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>неожиданные обновления.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>State</h4><p>Позволяет объекту варьировать свое поведение в зависимости от внутреннего состояния. Извне создается впечатление, что изменился класс объекта.</p><p><strong><em>Применимость</em></strong></p><ul><li>когда поведение объекта зависит от его состояния и должно изменяться во время выполнения;</li><li>когда в коде операций встречаются состоящие из многих ветвей условные операторы, в которых выбор ветви зависит от состояния.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Context - определяет интерфейс, представляющий интерес для клиентов, хранит экземпляр подкласса Concrete State, которым определяется текущее состояние;</li><li>State - определяет интерфейс для инкапсуляции поведения, ассоциированного с конкретным состоянием контекста;</li><li>Concrete State - реализует поведение, ассоциированное с некоторым состоянием контекста Context.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/51ad065237bfe5b76dadff805e1e03d0/href">https://medium.com/media/51ad065237bfe5b76dadff805e1e03d0/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>локализует зависящее от состояния поведение и делит его на части, соответствующие состояниям;</li><li>делает явными переходы между состояниями;</li><li>можно разделять объекты состояния.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>может усложнить код, если состояний мало и они редко меняются.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Strategy</h4><p>Определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми. Позволяет изменять алгоритмы независимо от клиентов, которые ими пользуются.</p><p><strong><em>Применимость</em></strong></p><ul><li>имеется много родственных классов, отличающихся только поведением;</li><li>вам нужно иметь несколько разных вариантов алгоритма;</li><li>в алгоритме содержатся данные, о которых не должен знать клиент;</li><li>в классе определено много поведений, что представлено разветвленными условными операторами.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Strategy - объявляет общий для всех поддерживаемых алгоритмов интерфейс;</li><li>Concrete Strategy - реализует алгоритм, использующий интерфейс, объявленный в Strategy;</li><li>Context - конфигурируется объектом класса Concrete Strategy, хранит ссылку на объект класса Strategy, может определять интерфейс, который позволяет объекту Strategy получить доступ к данным контекста.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37e886d87fec5794564ef22da9efaa41/href">https://medium.com/media/37e886d87fec5794564ef22da9efaa41/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>позволяет вычленить семейства родственных алгоритмов;</li><li>альтернатива порождению подклассов;</li><li>с помощью стратегий можно избавиться от условных операторов;</li><li>выбор реализации поведения внутри стратегии.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>клиенты должны знать о различных стратегиях;</li><li>обмен информацией между стратегией и контекстом;</li><li>увеличение числа объектов.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Template Method</h4><p>Определяет структуру алгоритма и позволяет подклассам переопределить некоторые шаги алгоритма, не изменяя его структуру в целом.</p><p><strong><em>Применимость</em></strong></p><ul><li>чтобы однократно использовать инвариантные части алгоритма, оставляя реализацию изменяющегося поведения на усмотрение подклассов;</li><li>когда нужно вычленить и локализовать в одном коде поведение, общее для всех подклассов, дабы избежать дублирования;</li><li>для управления расширениями подклассов.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Abstract Class - определяет абстрактные примитивные операции, замещаемые в конкретных подклассах для реализации шагов алгоритма, реализует шаблонный метод, определяющий скелет алгоритма;</li><li>Concrete Class - реализует примитивные операции, выполняющие шаги алгоритма способом, который зависит от подкласса.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1ab3451de2643305afe638328e1b3b16/href">https://medium.com/media/1ab3451de2643305afe638328e1b3b16/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>облегчает повторное использование кода.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>жесткая ограниченность скелетом алгоритма;</li><li>можно нарушить принцип подстановки Барбары Лисков;</li><li>с ростом шагов становится сложно поддерживать.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Visitor</h4><p>Описывает операцию, выполняемую с каждым объектом из некоторой структуры. Позволяет определить новую операцию, не изменяя классы этих объектов.</p><p><strong><em>Применимость</em></strong></p><ul><li>в структуре присутствуют объекты многих классов с различными интерфейсами и вы хотите выполнять над ними операции, зависящие от конкретных классов;</li><li>над объектами, входящими в состав структуры, надо выполнять разнообразные, не связанные между собой операции и нет желания засорять классы такими операциями;</li><li>классы, устанавливающие структуру объектов, изменяются редко, но новые операции над этой структурой выполняются часто.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Visitor - объявляет операцию Visit для каждого класса Concrete Element в структуре объектов;</li><li>Concrete Visitor - реализует операции, объявленные в Visitor;</li><li>Element - определяет операцию Accept, которая принимает посетителя в качестве аргумента;</li><li>Concrete Element - реализует операцию Accept, которая принимает посетителя в качестве аргумента;</li><li>Object Structure - может перечислить свои элементы, предоставить посетителю интерфейс для посещения элементов.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e88901d7224eacac71b92ad1ad40ded/href">https://medium.com/media/1e88901d7224eacac71b92ad1ad40ded/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>упрощает добавление новых операций;</li><li>объединяет родственные операции.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>добавление новых классов Concrete Element затруднено;</li><li>поддержка различных иерархий классов затруднена;</li><li>нарушение инкапсуляции.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*824zS8n-lfLVyDL8Ovxe6Q.png" /></figure><p>Мы рассмотрели все паттерны, описанные в книге GoF :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=386bda4ae328" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-sbermarket-blog/gof-on-ruby-3-386bda4ae328">GoF on Ruby # 3</a> was originally published in <a href="https://medium.com/tech-sbermarket-blog">tech.sbermarket.blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Эйчарские войны: Последние Рубисты. Полгода спустя.]]></title>
            <link>https://medium.com/tech-sbermarket-blog/%D1%8D%D0%B9%D1%87%D0%B0%D1%80%D1%81%D0%BA%D0%B8%D0%B5-%D0%B2%D0%BE%D0%B9%D0%BD%D1%8B-%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BD%D0%B8%D0%B5-%D1%80%D1%83%D0%B1%D0%B8%D1%81%D1%82%D1%8B-%D0%BF%D0%BE%D0%BB%D0%B3%D0%BE%D0%B4%D0%B0-%D1%81%D0%BF%D1%83%D1%81%D1%82%D1%8F-75f29339f92f?source=rss----6cc8f7d7d78c---4</link>
            <guid isPermaLink="false">https://medium.com/p/75f29339f92f</guid>
            <category><![CDATA[hr]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[devrel]]></category>
            <category><![CDATA[interview-questions]]></category>
            <category><![CDATA[hrtech]]></category>
            <dc:creator><![CDATA[Paul  Yakshankin]]></dc:creator>
            <pubDate>Sun, 31 Mar 2019 15:11:01 GMT</pubDate>
            <atom:updated>2019-11-07T09:56:07.182Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uj69Nuns5Tao82JagXf72Q.png" /></figure><p>Привет, я отвечаю за найм и развитие IT-специалистов в компании ‘Инстамарт Технолоджис’. Полгода назад мне посчастливилось выступить на конференции <a href="https://medium.com/tech-instamart-blog/rubyrussia-2018-f86830f066c5">RubyRussia</a>, где я рассказал о том, как мы подходим к найму, адаптации и обучению сотрудников. Мне давно хотелось облечь свои мысли в некий лонгрид, потому что а) 40 минут видео для современного мира это очень много б) могу. Кроме того в выступлении я не коснулся большого спектра вопросов, на которые попытаюсь ответить сейчас. Да, и мы за это время стали еще больше - нас в отделе уже 27 человек, а начинали мы полтора года назад с 7.</p><p>Самое главное, что нужно, на мой взгляд, понимать, это то что найм и развитие сотрудников вероятнее всего самые главные процессы в отделе, ведь главное что есть в вашем проекте - это люди. Люди, которые приходят, которые уходят, которые развиваются, и которые нанимают. И начну я с них. Я ничего бы не смог сделать без самого крутого HR на свете - это <a href="https://www.facebook.com/caterina.korolkova.3">Катя Королькова</a>. Это человек, который полностью перестроил мой взгляд на многие вещи, постоянно генерирует крутые идеи, и именно ее заслуга в том, что нас сейчас 27, и мы все до одного очень классные. Именно благодаря Кате я сейчас пишу на нашем корпоративном сайте. Именно благодаря Кате мы будем одеты в свой мерч. И именно благодаря Кате все и состоялось. Еще раз, главное в любом проекте - это люди.</p><p>Но, летс го. Итак вам надо нанимать людей. Рынок перегрет. Если вы установите тиндер, вы увидете кучу анкет ‘Я {#name}, и я в активном поиске разработчиков. Большой ли твой опыт на python?’ Нормально ли это? Да нифига. Хорошо ли то что вы тратите кучу денег и нервов на найм? Да нифига.</p><p>Тут надо просто смириться и исходить из ситуации. Да, появилась куча крипто (или крипо) компаний, которые готовы много платить, и также готовы с удовольствием схлопнуться через год. Да, и не только крипто, многие готовы вкладывать в IT по совету своих финансовых аналитиков. Да, у большинства разработчиков происходит сдвиг в мышлении: можно проработать полгода и не считаться “летуном” (это раньше работа менее 3 лет в компании накладывала ярлык шифтовости). Да, в выборе из 2 альтернатив - деньги или учиться и развиваться в компании, которая может в этом помочь, большинство выберет деньги. Но, камон, мы же не хотим страдать и винить кандидатов, мы хотим становиться больше и лучше. Даже несмотря на низкий уровень подготовки спецов в вузах, даже несмотря на то, что за качественных специалистов надо вроде как много платить. Даже несмотря на то, что к вам приходит человек освоивший на курсах php за 6 часов 66 минут, и, собственно 666 т. р. и просит.</p><p>Давайте начнем с самого грустного - внутренних ошибок. Я не пошел даже собеседоваться в одну международную компанию после того как 10 разных HR из 10 разных HR-агентств написали мне об этой вакансии. Если хаос в найме, то скорее всего, хаос во всем, рассудил я. Хаос при найме обычно ведет к разбалансировке зарплат, хаос в остальном приводит к отсутствию технического развития большинства сотрудников, и начинается текучка. При этом HR-бренд у многих, даже очень серьезных компаний отсутствует как класс.</p><p>Через боль и страдания, мы приходим к тому, о чем я говорил в самом начале - сотрудники это больше чем ресурс, их состояние и настроение надо мониторить и обеспечивать их развитие. А чтобы они к вам вообще пришли придется попотеть и влиять будет абсолютно все - один мой приятель отказался от продолжения диалога по вакансии после вида переполненной мусорки на кухне (это не у нас, если что:))</p><p>Когда я пришел нам надо было сильно расширяться, но стартовая позиция была не очень выгодная - мы сидели в офисе класса Z с ограниченным бюджетом и отсутствием оффера как документа. Кроме того мы e-commerce проект, в который априори привести людей сложнее. И рассматривать мы могли только людей из Москвы. Кузнец сразу взялся за дело, и у нас вскоре появились макбуки для сотрудников, оффер, матрицы компетенций, планы развития, планы собеседований (меня не устроило собеседование самого себя:)), библиотека профессиональной литературы и хэндбук, и, потихоньку, маховик начал раскручиваться. Потом пришла Катя, и мы реализовали вместе то, о чем я не мог и мечтать - релокационный пакет, мерч отдела, сайт, начали оплачивать сотрудникам билеты на конференции и выступать на них. Спустя пару месяцев после ее прихода мы отказались от услуг всех кадровых агентств. Сейчас мы вместе проводим встречи по аттестации и мотивации сотрудников - выясняем чего они достигли, определяем их дальнейший вектор развития и мотивацию. Аттестация - это конечно очень страшное слово, на самом деле это просто check скиллов, не влияющий ни на что (это к слову очень важно донести до ребят, если будете проводить). Чуть не забыл, the last but not the least - мы стали нанимать и адаптировать людей еще быстрее. Не знаю как это у нее получается, но Катя очень крута.</p><p>Конечно, пока мы выстраивали процессы все было сложно - % принятых офферов составлял 25, а собеседовали мы просто по 3 раза в день. Но постепенно запущенные процессы стали работать на нас, % принятых офферов вырос до 70, а собеседовать, благодаря прекрасному HR-скринингу, стали гораздо меньше. Вместе мы набрали PM, DevOps, нескольких дизайнеров, море рубистов и QA, и, даже, самые проблемные вакансии - Frontend, стали закрывать с гораздо меньшей болью, хотя нервы все равно щекочет изрядно. Ах да, еще, в совокупности мы наняли 23 человек, только 1 не прошел испытательный срок, 2 других покинули нас уже после него: для быстроразвивающейся компании у нас очень маленькая текучка и мы этим гордимся. Объясняется это хорошими интервью и выстроенным процессом адаптации.</p><p>Что мы сделали для найма и развития своих сотрудников я описал выше, еще раз хочу акцентировать внимание на том, что эти процессы не менее сложные и важные чем сама разработка. Уже недостаточно разместить вакансии на HH и потратить 2 вечера CTO на проведение собеседований. Над HR-брендом надо работать, работать и работать.</p><p>Вернемся к найму, адаптации и развитию сотрудника. Из каких же этапов это все состоит?</p><ul><li>Анализ ситуации</li><li>Постановка задачи</li><li>Составление плана поиска</li><li>Анализ резюме</li><li>Интервью</li><li>Принятие решений и обратная связь</li><li>Оффер</li><li>Выход на работу и последующая адаптация</li><li>Прохождение испытательного срока и развитие сотрудника</li></ul><h4><em>Анализ ситуации</em></h4><p>Начинается все с анализа ситуации - обычно про это все забывают и ищут сотрудников несколько месяцев. Тут нужно задать себе много увлекательных вопросов - от захочет ли желаемый кандидат к нам придти на текущем уровне инфраструктуры, в каком состоянии рынок и где искать до самого главного, на мой взгляд, вопроса - как мы сможем стать привлекательнее для кандидатов?</p><p>Привлекательность для кандидатов, или HR-бренд складывается из многих аспектов. Вы можете организовывать крутые конференции и митапы. Но даже если ваши сотрудники просто выступают на них, и вы оплачиваете им билеты, это уже повысит шансы. Если у вас крутой опенсорс, вас тоже все знают. Курсы английского, макбуки, белая зарплата, социальный пакет, гибкий график, мерч отдела уже давно становятся необходимой составляющей. Не стоит забывать, что с большей охотой идут в компании с высокой инженерной культурой - тестами, настроенным CI / CD и прочим. Все это вы можете донести кандидатам через крутые собеседования и блоги. Как мы:)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Постановка задачи</em></h4><p>После артподготовки в виде анализа ситуации и плана мероприятий по улучшению привлекательности, можно приступить к постановке задачи. Сейчас на западе очень популярна книга “Who”, на мой взгляд предлагаемые концепции не совсем хорошо ложатся именно на найм разработчиков, но что из нее можно почерпнуть, так это то что нужно определиться: а что вы хотите от кандидата скажем через год? Продумайте какими задачами будет заниматься ваш сотрудник, расставьте его профессиональные качества в порядке значимости, и попытайтесь оценить каким он должен быть по софт-скиллам, чтобы оценить корпоративный юмор.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Составление плана поиска</em></h4><p>Если вы не HR, вам вряд ли будет интересно где искать кандидатов. Это отдельная большая тема, а я скажу просто 2 факта. Лучше всего работает внутренняя рекомендация. Я привел в эту компанию 3 человек на очень важные роли, и ими все восхищаются. Это очень важно. Да, не менее важно, за успешную внутреннюю рекомендацию премировать.</p><p>Второй факт - подумайте о том, чтобы разместить листовки в технических вузах (да, я не разочаровался в молодежи), и поглядывать на курсы по обучению программированию. Я не большой энтузиаст этого всего, но иногда оттуда выходят очень приличные специалисты. Все зависит от людей.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Анализ резюме</em></h4><p>Про анализ резюме скажу тоже немного - не всем так повезло, как нам с нашим HR, которому мы полностью доверили отбор кандидатов, и, мы вступаем в процесс уже на этапе технического собеседования. Если вы хотите того же самого (чтобы не было бесполезной прокси из рекрутера, не разбирающегося в технологиях), рекомендую сделать так, чтобы ваш HR сидел вместе с командой. С ним надо быть заодно, и ему надо давать своевременный фидбек. То есть необходимо готовить и вовлекать человека в процесс. Нам, слава всему, этого делать не пришлось.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Интервью</em></h4><p>У нас общение с кандидатом (помимо переписок) происходит в 3 этапа. Ваша схема может быть принципиально другой, но главное помнить, что вы не Microsoft, и на 6 собесов у вас у кандидата просто нет времени. Обязательны только те этапы, которые добавляют информации как компании, так и кандидату. Не стоит множить сущности без необходимости, в общем, всему бритва Оккама.</p><p>Первый этап - это скрининг (30 минут), который делает ваш HR. Именно от него исходит отсев по soft-скиллам (а у нас еще и по hard-скиллам), на техническом (втором этапе - 1.5 - 2 часа) он происходит крайне редко - например, если кандидат решил собеседоваться с бутылочкой пива (такое в моей практике было).</p><p>В случае успешного тех.собеседования при необходимости звонит CTO и проясняет неясные моменты. Кандидату приятно когда звонит CTO, а у вас на руках мнение 3-4 людей изнутри. Но мы (кроме совсем граничных случаев) уже практически отошли от этой практики, так как дополнительно мотивировать кандидатов или объяснять им что-то уже стало не нужно.</p><p>Скрининг и как его проводить HR - тема отдельная, главное, что после него кандидаты к нам приходят, зная все о компании, работе нашего отдела и технологиям, а мы знаем многое о нем. Предлагаю остановиться на техническом интервью.</p><p>Само техническое интервью (на мой взгляд) должно состоять из 4 этапов и задача первых двух - планомерно подвести к аду, через который кандидату предстоит прошагать на третьем:</p><ul><li>Рассказ о компании и задачах (5 минут)</li><li>Вопросы по опыту работы (10 минут)</li><li>Технические вопросы (1 - 1.5 часа)</li><li>Ответы на вопросы кандидата (10 минут)</li></ul><p>Важно понимать, что собеседование - это обоюдная продажа, и, вначале, нужно по максимуму заинтересовать человека - всем интересен путь развития компании, в наше кризисное время крайне важно донести, что вы не разбежитесь через пару месяцев забрав макбуки в качестве последней невыплаченной заработной платы, подробно стоит рассказать о технической организации проекта, в каком виде будет ставиться задача, насколько она будет проработана, кто ее будет ревьюить и выкатывать. И завершите рассказ о компании тем, что вы сделаете для того, чтобы кандидат у вас стал еще круче как специалист.</p><p>Вторая часть - это вопросы об опыте. На мой взгляд релевантны максимум 2 последних места работы (у меня есть мнение, что людям свойственно меняться:)). Не надо спрашивать вопрос про самую интересную задачу. Это всегда не конкретно, и всегда ставит в тупик. Если глобально, мне лично интересно, чем человек вообще занимался на работе. Для этого можно взять пару последних больших задач на прошлом месте, и пользоваться простой концепцией STAR:</p><ul><li>S - Situation (что была за ситуация?)</li><li>T - Task (в чем задача и кто ее ставил?)</li><li>A - Action (действие, которое предпринял кандидат?)</li><li>R - Result (итог работы, почему это именно достижение кандидата?)</li></ul><p>А дальше для кандидата начинается гоночная миссия из первой мафии. Ваша же задача: узнать, а инженер ли перед вами, способный мыслить и обдумывать задачи или копипастер со stackoverflow. Многие ограничиваются задачами по языку и фреймворку, но это лишь надстройка, на мой взгляд, необходимо проверить базис. Важно понять способность к обучению, мы даже иногда практикуем такой подход - если не знаешь ответ, вот тебе статья с примером, сможешь сделать исходя из нее? И наконец вы должны показать как много у человека пробелов, а их много у всех. Именно за это вам будут благодарны. Слегка будут не любить, но будут благодарны. Давайте резюмируем цели интервью:</p><ul><li>Понять, что кандидат знает</li><li>Понять, что он может узнать</li><li>Показать как много он не знает, но может узнать у вас.</li></ul><p>Давайте сконцентрируемся на вопросах Ruby-разработчику (я собеседую не только их, а еще и Devops, PM, Designer, и, в качестве чирлидерши, Frontend разработчиков, но, для примера, давайте все таки остановимся на Backend программистах). Все технические вопросы должны быть разбиты на блоки, и последовательность блоков значения не имеет. Каждый блок должен дополнять ответ на вопрос - что за специалист перед вами?</p><p>Перво-наперво я рекомендую обойтись без задач из умных книжек про горы. “Сколько мячей влезет в автобус” и прочие увлекательные логические вопросы не показывают ничего, также как успех на олимпиаде не гарантирует что человек будет крутым специалистом.</p><p>Пройдемся по блокам? У нас они такие</p><ul><li>Ruby</li><li>Rails</li><li>ОС</li><li>Алгоритмы</li><li>Типы данных</li><li>БД</li><li>ООП, архитектура и паттерны</li><li>Сети</li><li>Git</li><li>Обо всем</li></ul><p>Вопросы по языку программирования, конечно же, важны, ведь это ваш основной инструмент, и его надо знать хорошо - можно спросить про блоки, исключения, цепочку наследования, переменные. Желательно, чтобы это были вопросы с экрана компьютера, с кодом воспроизводящим конкретную рабочую ситуацию. То есть не надо спрашивать про файберы, если вы их не используете. Вопросы по rails мы задаем на коллбэки, n+1, связи - ничего за рамками гайдов и типовых ситуаций тут тоже нет. Но справляются далеко не все:)</p><p><em>Примеры вопросов по блокам:</em></p><ul><li>Как можно вызвать метод у объекта? Назови как можно больше способов.</li><li>Что за атака CSRF, и какие методы защиты от нее есть в Rails?</li></ul><p>Вопросы по БД нужны, чтобы определить сможет ли человек работать с запросами за пределами ActiveRecord - у нас, например, многомиллионные таблицы, и нам это очень важно. Также, вам вряд ли нужен разработчик, который не понимает как пойдет запрос от клиента, поэтому нужно узнать, что кандидат знает о сетях. Вопросы по ОС скажут, можно ли человеку давать доступ на сервер:). Вопросы по Git хорошо показывают в каких командах работал человек и насколько тщательно он изучает инструменты.</p><p><em>Примеры вопросов по блокам:</em></p><ul><li>Есть таблица сотрудников (поля - id, salary, department). Давай выведем всех сотрудников, и к каждому, дополнительно, среднюю заработную плату по его отделу. У нас PostgreSQL и это важно (да я знаю, что это из документации, не буду же я наши реальные вопросы сливать:))</li><li>Что значит “база ушла в swаp” и нормальная ли эта ситуация?</li><li>Как работает CORS, и для чего это нужно?</li><li>git pull и git fetch. В чем разница?</li></ul><p>Вопросы про ООП и архитектуру проектов нужны для понимания, читает ли он книги. Эрика Эванса, например. Ответы на вопросы по алгоритмам и типам данных скажут, сможет ли кандидат оптимизировать свои решения, и есть ли у него база как таковая. Есть еще вопросы по различным технологиям - это довольно большой набор от разбора регэкспы, до рассказа о юникоде.</p><p><em>Примеры вопросов по блокам:</em></p><ul><li>Низкая связанность / высокое зацепление. Можешь привести примеры?</li><li>Напиши функцию, которая определит, является ли строка палиндромом.</li></ul><p>И тут мы подошли к холиварному вопросу. Надо ли писать код на собеседовании? Да, надо. Мы берем не за модный лук или приятность в общении, а за умение программировать, это наша работа. На самом деле, это наш единственный способ увидеть реальный код кандидата и его отношение к этому коду. Также, нам нужно проверить работу в условиях стресса.</p><p>На мой взгляд отказ писать код происходит только от недостатка знаний. Мы даем обычно одну задачу на знание языка - как правило с блоками (например, реализовать свой map), и одну на алгоритмику. Прекрасно будет, если эту задачу можно решить разными способами с разной сложностью, и вы пройдете с кандидатом путь от неоптимального решения к оптимальному.</p><p>Еще пару слов скажу об открытых вопросах. Их все очень любят, но конструктивный диалог по ним происходит только с разработчиками высокого уровня.</p><p><em>Примеры таких вопросов:</em></p><ul><li>MySQL vs PostgreSQL, в чем отличия?</li><li>ActiveRecord - паттерн или антипаттерн?</li><li>Что нравится, а что не нравится в Rails?</li></ul><p>Но тут мы уже близко подходим к собеседованиям лидов и технических директоров, которые вообще лучше проводить, на мой взгляд, в формате воркшопа. И все это тема для отдельного разговора.</p><p>Итак, технические вопросы кончились, вы поменялись ролями, и кандидат задает свои вопросы. Тут желательно заранее составить список типовых вопросов и ответов (для сотрудников, которые не так часто проводят собеседования), и отвечать честно. После выхода на работу будет некрасиво, если вы говорили о 90% покрытии, а у вас 0. К слову о процентах, из вопросов кандидата его мотивация читается на 100%.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Принятие решения и обратная связь</em></h4><p>Ну, о том, что принимать решение нужно быстро, необходимости говорить нет. Мы даем ответ, в течении 3-4 дней, и даем его в любом случае.</p><p>Я бы хотел поговорить о том, чего не надо делать при принятии решения. Первое, не надо гадать на гитхабе. Меня, да и многих, раздражает формулировка “пришлите куски кода, которыми вы гордитесь”. Я очень много работаю и много чем горжусь, но не хочу идти в суд из-за NDA, прислав это вам. На мой взгляд, если человек не постоянный контрибьютор в опенсорс, это вообще бессмысленное занятие - вы не узнаете писал ли человек этот код сам, сколько он его писал, единственное что вы узнаете - с каким задором человек сольет вашу кодовую базу при увольнении. Да, и вы потратите очень много времени.</p><p>Второе, давать тестовое не нужно. У вас была куча времени на проверку скиллов. А вот у кандидата времени на вас ограничено, и он скорее пойдет туда где тестового нет. Единственное исключение - если вы Google, или вы нанимаете джуниоров (это может выступать в роли небольшого первичного фильтра). Но в любом случае вы опять таки не знаете кто тестовое в итоге сделал - кандидат или его друг. Да, и вы потратите очень много времени.</p><p>Третье, что не рекомендую делать, это звонить на прошлые работы. Это можно сделать только если вы приятель рекомендателя. Вы напряжете кандидата, если он об этом узнает, а свои сомнения не развеете, так как вы не знаете компетентность рекомендателя. Кроме того есть масса примеров, что у человека получалось в десяти других фирмах, но в этой конкретно (куда собираетесь звонить) у него не получилось бы ничего и никогда.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Оффер</em></h4><p>И вот мы принимаем решение. Софт скиллы должны влиять только на то, будем ли вообще после интервью думать об оффере. При этом, для нас софт скиллы это общая адекватность, а не “пунктуальность, стрессоустойчивость, ответственность”.</p><p>Сумма оффера должна зависеть только от хард скиллов, она складывается исходя из их проекции на наши грейды и ожиданий кандидата. Кроме того, есть такие хард скиллы, за которые компании готовы серьезно платить. (это касается узких специалистов).</p><p>Мы также рекомендуем ставить дедлайн кандидату по принятию решения (это 3-4 рабочих дня) и оставить его на это время в покое. Мы не любим торговлю офферами и не вступаем в эту игру. Да, и никогда не высылайте оффер в тот же день - у кандидата пропадает инстинкт охотника:)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Выход на работу и последующая адаптация</em></h4><p>На испытательном сроке главное не забывать, что он в первую очередь для вас. Мнение о компании формируется именно на испытательном сроке. Когда первые дни представляют набор квестов - сходи к админу по коридору налево, разверни проект с помощью 666 интуитивно понятных команд - это не круто.</p><p>Для всего этого есть очень крутая штука - концепция своего парня (buddy), прикрепляемого к новичку. Он отведет нового сотрудника к вратам ада - в бухгалтерию, будет ходить с новичком на обеды, объяснит кто есть кто, поможет развернуть проект и сделать первую задачу.</p><p>Вообще, адаптацией должен заниматься весь коллектив (не только buddy). Это не только ad hoc работа, но и подготовка заранее, например, составление хэндбука (опишите в нем все с чем сталкивается сотрудник - от инфраструктуры проекта, и как брать задачу из бэклога, до того, у кого просить себе новый стул после раскачки старого. Хэндбук избавит вас от долгих разговоров, а если он у вас еще и частично открыт, даст позитивную инфу кандидатом и подчеркнет открытость компании). Недавно Катя внедрила очередную крутую штуку: “лист новичка”. На красивом бланке, люди, которые еще не успели настроить свой новый мак, пишут свои ники в github, trello, чтобы мы могли быстрее и организованнее выдать доступы.</p><p>Первые задачи также очень важны. Я работал в разных компаниях, но адекватная система выставления первых задач была только у одной - “дадим одну простую задачу и одну сложную”. Это уже круто, но можно пойти дальше и воспользоваться концепцией SMART (я люблю все структурировать:))</p><ul><li>S (specific) - задача конкретная</li><li>M (measurable) - измеримая</li><li>A (attainable) - достижимая</li><li>R (relevant) - значимая</li><li>T (time-bounded) - с конкретным сроком выполнения.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sc0Okjx7_UMc0vYR4QQbHA.png" /></figure><h4><em>Развитие сотрудника</em></h4><p>Но вот сотрудник прошел испытательный срок, стресс отодвинут на второй план,и мы можем наконец заняться его развитием. Профессиональный программист хочет постоянно развиваться, так как видит, что технологии меняются очень быстро, и хочет остаться востребованным. Но в России с этим по-прежнему крайне сложно - многих хороших сотрудников не замечают, дают рутинные задачи, отсутствуют бонусы и признание заслуг. Давайте рассмотрим как их развивать и мотивировать.</p><p>Большие конференции проходят редко, но дают сильную встряску из-за общения с крутыми спикерами и друзьями. Также они дают быть в курсе последних технологий. Но в плане прокачки, большую пользу дают внутренние доклады - например раз в месяц CTO рассказывает о направлении движения проекта, или кто-то делает доклад о последней прочитанной книге. Наконец вы просто можете сесть и посмотреть вместе чужие доклады, а потом обсудить.</p><p>Не меньшую роль играют и хакатоны - они выполняют очень крутую функцию. Огромная проблема многих разработчиков (я уже писал ранее) в том, что они не не видят проект дальше своей фичи. И забывают о пользователях. Хакатон позволяет побыть в другой роли (например менеджера), взглянуть на проект с точки зрения пользователя и бизнеса. Главное, не проводить их слишком часто - иначе получите толпу кофейных зомби. Также не надо оценивать сотрудников по результатам хакатона (это не имеет отношения к повседневной работе), и нужно помнить, что многим людям не подходит такой формат.</p><p>Но все это хорошо, как разовые эвенты. Есть очень крутые штуки для отслеживания прогресса - матрицы компетенций. По сути, это таблица, заполняемая для каждого сотрудника, по горизонтали - навыки, а по вертикали - уровень владения навыком. Текущий уровень определяется на собеседованиях и аттестациях, соответствующая клетка на пересечении закрашивается. Примеров таких матриц в открытом доступе много, например, она есть у <a href="https://ru.hexlet.io/">Hexlet</a>.</p><p>У нас матрица компетенций Backend разработчика включает в себя 34 навыка (у Frontend меньше), и мы достаточно долго ее прорабатывали. Кроме того, нам стало недостаточно классического junior / middle / senior деления, и мы ввели промежуточный этап между middle и senior. Все 4 грейда привязаны к зарплатам, которые мы готовы платить разработчикам данного уровня. Когда знания разработчика по технологиям раскиданы между тремя грейдами, на помощь приходят среднее арифметическое, и если совсем заморочиться коэффициенты ранжирования. Есть еще узкоспециализированные специалисты, например dba, у которых зарплата складывается из его грейда по остальным технологиям + надбавка за технологию которую он знает хорошо.</p><p>Навыки у нас делятся на две группы. Первая (и самая большая) группа навыков в матрице - это, конечно, техническая - сколько языков знает программист и насколько глубоко, какие его знания в базах данных, и вообще во всех штуках, которые мы спрашивали на собеседовании - от полнотекстового поиска до рабочего окружения.</p><p>Вторая отражает навыки по выполнению рабочих задач и организаторские способности - насколько хорошо человек успевает в сроки, сколько тратит на багфиксинг - тут на помощь вам может прийти, например, JIRA. Насколько качественный код выдает, умеет ли работать с legacy, может ли помогать младшим товарищам, есть ли задатки тимлида - эти показатели не измеряется количественно, но наблюдаются эмпирически.</p><p>В итоге, после собеседования / аттестации вы предоставите сотруднику наглядную оценку его знаний на конкретный момент. Также на матрице удобно показать, что если он продвинется вправо по матрице компетенций до следующего грейда, то сможет получить более интересные задачи и другую зарплату. Еще, это хороший способ держать зарплаты равных по скиллам специалистов на одном уровне,</p><p>На основе матрицы компетенций пишутся планы развития. К сожалению, люди не будут сами развиваться, и их можно понять - им хочется очень многого, в результате они хватают всего по верхам, и глубокого развития не происходит. Люди забрасывают это и просто работают. Ваша цель - направить их по правильному руслу. Оно должно включать в себя как и серьезные книги, так и очень много практики - читать одни книги всем надоест. Важно перед составлением плана обговорить его с человеком, чтобы начать двигаться в направлении интересном как ему, так и компании. План должен быть рассчитан на 8-9 месяцев, так как жизнь превратит это в год - так повышение оклада по выходу на новый уровень, станет индексацией за хорошее развитие. При составлении плана помните, что человек должен успевать жить:)</p><p>План разбивается на недельные (месячные) блоки. Идеально, когда книги человек читает в метро, а в свободное время делает практику. Необходимость каждого пункта плана должна быть обоснована для человека, и должно быть понятно как за выполнение отчитываться. Отчетность может быть совершенно разная, мы выделили 4:</p><ul><li>Рассказ на планерке (о книге)</li><li>Беседа с куратором на 5-10 минут</li><li>Внутренний доклад</li><li>Проект в github (практика)</li></ul><p>Мотивировать к дальнейшему обучению будет, конечно, в первую очередь повышение зарплаты. Но не забывайте хвалить человека на планерках и сразу давать рабочие задачи по изученным технологиям. Кроме того, если в плане много практики, профиль на github будет разрастаться.</p><p>Эффект от внедрения планов развития в том или ином виде огромный - вы это сразу заметите по количеству выполненных задач, возросшему качеству кода и фидбеку от тестеров. И всегда помните старый анекдот - ‘вы не боитесь что ваши сотрудники у вас всему научатся и уйдут? - нет я боюсь что они ничему не научатся и останутся”</p><p>Мы затронули, мне кажется, все основные темы развития и поиска сотрудников, на которые, вы как разработчик, можете и должны повлиять. Это сложный процесс, внедряя который, вы потратите, конечно, определенное время, но оно с лихвой окупится. Удачи в поисках!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=75f29339f92f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-sbermarket-blog/%D1%8D%D0%B9%D1%87%D0%B0%D1%80%D1%81%D0%BA%D0%B8%D0%B5-%D0%B2%D0%BE%D0%B9%D0%BD%D1%8B-%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BD%D0%B8%D0%B5-%D1%80%D1%83%D0%B1%D0%B8%D1%81%D1%82%D1%8B-%D0%BF%D0%BE%D0%BB%D0%B3%D0%BE%D0%B4%D0%B0-%D1%81%D0%BF%D1%83%D1%81%D1%82%D1%8F-75f29339f92f">Эйчарские войны: Последние Рубисты. Полгода спустя.</a> was originally published in <a href="https://medium.com/tech-sbermarket-blog">tech.sbermarket.blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GoF on Ruby # 2]]></title>
            <link>https://medium.com/tech-sbermarket-blog/gof-on-ruby-2-e326a7b0d209?source=rss----6cc8f7d7d78c---4</link>
            <guid isPermaLink="false">https://medium.com/p/e326a7b0d209</guid>
            <category><![CDATA[patterns]]></category>
            <category><![CDATA[fog]]></category>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Paul  Yakshankin]]></dc:creator>
            <pubDate>Sun, 31 Mar 2019 10:50:54 GMT</pubDate>
            <atom:updated>2019-11-07T09:52:09.794Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2wA7bEYm2hCO0dmXbHCfkw.png" /></figure><p>Привет, сегодня мы продолжаем говорить о паттернах проектирования: в <a href="https://medium.com/tech-instamart-blog/gof-on-ruby-1-536c4b001e06">прошлый раз </a>мы рассмотрели порождающие паттерны, теперь пришло время структурных.</p><p><em>Напоминаю: все примеры кода абстрактные, и призваны лишь выразить общую идею реализации паттерна.</em></p><h3>Структурные паттерны</h3><p>В структурных паттернах рассматривается вопрос о том, как из классов и объектов образуются более крупные структуры. Структурные паттерны уровня класса<em> </em>используют наследование для составления композиций из интерфейсов и реализаций.</p><h4>Adapter</h4><p>Преобразует интерфейс одного класса в интерфейс другого, который ожидают клиенты.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо использовать класс, но его интерфейс не соответствует потребностям;</li><li>необходимо создать повторно используемый класс, который должен взаимодействовать с заранее неизвестными или не связанными с ним классами.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Target - определяет зависящий от предметной области интерфейс, которым пользуется Client;</li><li>Client - вступает в взаимоотношения с объектами, удовлетворяющим интерфейсу Target;</li><li>Adaptee - определяет существующий интерфейс, который нуждается в адаптации;</li><li>Adapter - адаптирует интерфейс Adaptee к интерфейсу Target.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f9e02077747cc6a451e6ceff8527a826/href">https://medium.com/media/f9e02077747cc6a451e6ceff8527a826/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>скрывает от клиента подробности преобразования различных интерфейсов.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>усложняет код программы из-за введения дополнительных классов.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Bridge</h4><p>Отделяет абстракцию от реализации так, чтобы и то и другое можно было менять независимо.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо избежать постоянной привязки к реализации;</li><li>абстракции и реализации должны расширяться новыми подклассами;</li><li>изменения в реализации абстракции не должны сказываться на клиентах;</li><li>необходимо разделить одну реализацию между несколькими объектами и скрыть этот факт от клиента.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Abstraction - определяет интерфейс абстракции и хранит ссылку на объект Implementor;</li><li>Refined Abstraction - расширяет интерфейс, определенный абстракцией;</li><li>Implementor - определяет интерфейс для классов реализации;</li><li>Concrete Implementor - содержит конкретную имплементацию класса Implementor.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7b4433baec0e2209e6ef15ff01531954/href">https://medium.com/media/7b4433baec0e2209e6ef15ff01531954/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>отделяет реализацию от интерфейса;</li><li>повышает степень расширяемости;</li><li>скрывает детали реализации от клиентов.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>усложняет код программы из-за введения дополнительных классов.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h3>Composite</h3><p>Компонует объекты в древовидные структуры для представления иерархий часть-целое. Позволяет клиентам единообразно трактовать индивидуальные и составные объекты.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо представить иерархию объектов вида часть-целое;</li><li>клиенты должны единообразно трактовать составные и индивидуальные объекты.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Component - объявляет интерфейс для компонуемых объектов, предоставляет подходящую реализацию, общую для всех классов, объявляет интерфейс для доступа к потомкам и управлению ими;</li><li>Leaf - определяет поведение примитивных объектов в композиции;</li><li>Composite - определяет поведение компонентов у которых есть потомки, хранит компоненты-потомки;</li><li>Client - манипулирует объектами композиции через интерфейс Component.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/50c967db0a7d85d8e2f22f99e6fcf152/href">https://medium.com/media/50c967db0a7d85d8e2f22f99e6fcf152/href</a></iframe><p><em>Плюсы</em></p><ul><li>определяет иерархии классов;</li><li>упрощает архитектуру клиента;</li><li>облегчает добавление новых видов компонентов.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>способствует созданию общего дизайна.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Decorator</h4><p>Динамически добавляет объекту новые обязанности. Является альтернативой порождению подклассов с целью расширения функциональности.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо динамически добавлять обязанности объектам;</li><li>расширение путем введения подкласса невозможно.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Component - определяет интерфейс для объектов, на которые динамически могут быть возложены дополнительные обязанности;</li><li>Concrete Component - определяет объект, на который возлагаются дополнительные обязанности;</li><li>Decorator - хранит ссылку на Component и определяет соответствующий ему интерфейс;</li><li>Concrete Decorator - возлагает дополнительные обязанности на компонент.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0eb61978becf1565bdb7f334176e1437/href">https://medium.com/media/0eb61978becf1565bdb7f334176e1437/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>большая гибкость нежели у наследования;</li><li>позволяет избежать перегруженных функциями классов на верхних уровнях иерархии.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>декоратор и его компонент не идентичны, трудность конфигурации;</li><li>существует множество мелких объектов.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Facade</h4><p>Предоставляет унифицированный интерфейс вместо набора интерфейсов некоторой подсистемы.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо представить простой интерфейс к сложной подсистеме;</li><li>между клиентами и классами реализации абстракции существует много зависимостей;</li><li>подсистему хочется разложить на слои.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Facade - знает каким классам подсистемы адресовать запрос;</li><li>Классы подсистемы - реализуют функциональность подсистемы, ничего не знают о Facade.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/df0624aef7c62df48d380663211d8958/href">https://medium.com/media/df0624aef7c62df48d380663211d8958/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>изолирует клиентов от компонентов подсистемы;</li><li>позволяет ослабить связанность между подсистемой и ее клиентами.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>может стать God Object.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Flyweight</h4><p>Использует разделение для поддержки множества мелких объектов.</p><p><strong><em>Применимость</em></strong></p><ul><li>в приложении используется большое число объектов;</li><li>накладные расходы на хранение высоки;</li><li>большую часть состояния объектов можно вынести во вне;</li><li>многие группы объектов можно заменить относительно небольшим количеством разделяемых объектов.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Flyweight - объявляет интерфейс с помощью которого приспособленцы могут получать внешнее состояние или как-то воздействовать на него;</li><li>Concrete Flyweight - реализует интерфейс класса Flyweight и добавляет при необходимости внутреннее состояние;</li><li>Unshared Concrete Flyweight - неразделяемый подкласс Flyweight;</li><li>Flyweight Factory - создает объекты-приспособленцы и управляет ими (обеспечивает должное разделение);</li><li>Client - хранит ссылки на одного или нескольких приспособленцев, вычисляет или хранит внешнее состояние приспособленцев.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0898ce35d297248f53558d86bcfa81f0/href">https://medium.com/media/0898ce35d297248f53558d86bcfa81f0/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>уменьшение общего числа экземпляров;</li><li>сокращение объема памяти.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>расходует время на поиск / вычисление контента;</li><li>усложняет код программы из-за введения множества дополнительных классов.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h3>Proxy</h3><p>Является суррогатом другого объекта и контролирует доступ к нему.</p><p><strong><em>Применимость</em></strong></p><ul><li>необходимо представить локального представителя вместо объекта, находящегося в другом адресном пространстве;</li><li>нужно создавать тяжелые объекты по требованию;</li><li>хочется контролировать доступ к исходному объекту.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Proxy - хранит ссылку, которая позволяет обратиться к реальному субъекту, предоставляет интерфейс, идентичный интерфейсу Subject, контролирует доступ к реальному субъекту;</li><li>Subject - определяет общий для Real Subject и Proxy интерфейс;</li><li>Real Subject - определяет реальный объект, представленный заместителем.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c43695aca3c7870ec748b4634f42b540/href">https://medium.com/media/c43695aca3c7870ec748b4634f42b540/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>позволяет контролировать объект незаметно для клиента;</li><li>может контролировать жизненный цикл служебного объекта.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>усложняет код программы из-за введения дополнительных классов;</li><li>увеличивает время отклика от сервиса.</li></ul><p>В следущий раз мы поговорим о паттернах поведения✌️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e326a7b0d209" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-sbermarket-blog/gof-on-ruby-2-e326a7b0d209">GoF on Ruby # 2</a> was originally published in <a href="https://medium.com/tech-sbermarket-blog">tech.sbermarket.blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GoF on Ruby # 1]]></title>
            <link>https://medium.com/tech-sbermarket-blog/gof-on-ruby-1-536c4b001e06?source=rss----6cc8f7d7d78c---4</link>
            <guid isPermaLink="false">https://medium.com/p/536c4b001e06</guid>
            <category><![CDATA[patterns]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[fog]]></category>
            <category><![CDATA[ruby]]></category>
            <dc:creator><![CDATA[Paul  Yakshankin]]></dc:creator>
            <pubDate>Sun, 31 Mar 2019 10:02:13 GMT</pubDate>
            <atom:updated>2019-11-07T09:50:24.602Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2waGhwvZtSwxqQz7xeyL8A.png" /></figure><p>Привет, меня зовут Паша, я тимлид в компании ‘Инстамарт Технолоджис’. И сегодня я хотел бы поговорить о паттернах проектирования.</p><p>Паттерн - это такая штука, которая описывает решение типовой задачи, снова и снова возникающей в нашей работе. В подавляющем большинстве случаев, вам не надо изобретать свой велосипед, его изобрели до вас, и он прекрасно едет. Для многих ситуаций продуманы и описаны взаимодействия объектов и классов для решения конкретной задачи. Именно это и называется паттернами проектирования.</p><p>Ruby-разработчики в основном знакомы только с принципами ООП (SOLID, GRASP, etc), так что возникла идея обратиться к канонической книге Банды Четырех, описывающей 23 классических паттерна проектирования и перенести их по мере возможности на ruby.</p><p>Есть распространенное мнение, что знание паттернов бесполезно джуну, так как он не знает куда их приткнуть, и бесполезно сеньору, так как он и так их применяет, не осознавая этого. Я не хотел бы вас в этом разубеждать, поэтому просто приведу свои аргументы за.</p><ol><li>Главная проблема современных разработчиков - то что они не видят проект дальше своей фичи. Мне кажется паттерны как раз позволяют взглянуть на проект с более высокой точки, оперируя терминами компонентов системы, а не конкретными деталями реализации отдельно взятой задачи.</li><li>Опыт предыдущих поколений - неплохая штука, его иногда надо использовать. Конечно, думать самому подходит ли это для данной конкретной ситуации никто не отменял.</li><li>Это понравится вашему PM. Можно повысить производительность, и не тратить время на изобретение колеса, а подумать над тем, чтобы с уже готовыми колесами, машина хорошо поехала.</li></ol><p><em>Все примеры кода абстрактные, и призваны лишь выразить общую идею реализации паттерна.</em></p><h3>Порождающие паттерны</h3><p>Они абстрагируют инстанцирование объектов и помогают сделать систему независимой от их способа создания и представления. То есть они инкапсулируют знания о конкретных классах, которые применяются в проекте и скрывают детали того, как эти классы создаются.</p><h4>Abstract Factory</h4><p>Предоставляет интерфейс для создания семейств объектов, не указывая их конкретных классов.</p><p><strong><em>Применимость</em></strong></p><ul><li>система не зависит от того как создаются и компонуются входящие в нее объекты;</li><li>входящие в семейство объекты должны использоваться вместе;</li><li>система должна конфигурироваться одним из семейств объектов;</li><li>нужно раскрыть только интерфейсы объектов, но не реализацию.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Abstract Factory - интерфейс для операций, создающих абстрактные продукты;</li><li>Concrete Factory - реализует операции, создающие конкретные объекты-продукты;</li><li>Abstract Product - объявляет интерфейс для объекта-продукта;</li><li>Concrete Product - определяет конкретный объект-продукт, создаваемый конкретной фабрикой;</li><li>Client - пользуется интерфейсами, объявленными в AbstractFactory и AbstractProduct.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2c29abd4c11454dac5aaf91f045efc24/href">https://medium.com/media/2c29abd4c11454dac5aaf91f045efc24/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>изолирует конкретные классы;</li><li>упрощает замену семейств продуктов;</li><li>гарантирует сочетаемость семейств продуктов.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>сложно добавить поддержку нового вида продуктов.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Builder</h4><p>Отделяет конструирование сложного объекта от его представления, так что в результате конструирования могут получаться разные представления.</p><p><strong><em>Применимость</em></strong></p><ul><li>алгоритм создания объекта не должен зависеть от того из каких частей он состоит;</li><li>процесс конструирования должен обеспечивать различные представления.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Builder - интерфейс для создания частей объекта-продукта;</li><li>Concrete Builder - конструирует и собирает части продукта посредством Builder, предоставляет интерфейс для доступа к продукту;</li><li>Director - конструирует объект, пользуясь интерфейсом Builder;</li><li>Product - сложный конструируемый объект, включает классы которые определяют составные части.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/73f4c1a2fc6b0a327517bacea75e587d/href">https://medium.com/media/73f4c1a2fc6b0a327517bacea75e587d/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>позволяет изменять внутреннее представление продукта;</li><li>изолирует код, реализующий конструирование и представление;</li><li>дает тонкий контроль над процессом конструирования.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>усложняет код из-за введения дополнительных классов;</li><li>клиент привязан к конкретным классам строителей.</li><li>дает тонкий контроль над процессом конструирования.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>FactoryMethod</h4><p>Определяет интерфейс для создания объекта, но оставляет подклассам решение о том, какой класс инстанцировать.</p><p><strong><em>Применимость</em></strong></p><ul><li>классу заранее неизвестно, объекты каких классов ему нужно создавать;</li><li>класс спроектирован так, чтобы объекты, которые он создает инстанцировались подклассами;</li><li>класс делегирует свои обязанности одному из нескольких вспомогательных классов.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Product - определяет интерфейс объектов, создаваемых фабричным методом;</li><li>Concrete Product - реализует интерфейс Product;</li><li>Creator - объявляет фабричный метод, возвращающий объект Product, может вызывать фабричный метод для создания объектов Product;</li><li>Concrete Creator - замещает фабричный метод, возвращающий ConcreteProduct.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37600f8860325ec3b3216a8ba770672a/href">https://medium.com/media/37600f8860325ec3b3216a8ba770672a/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>избавляет класс от конкретной привязки к продуктам;</li><li>выделяет код создания продуктов в одно место;</li><li>упрощает добавление продуктов в программу.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>для каждого класса продукта нужно создать свой подкласс создателя, что может привести к созданию больших параллельных иерархий.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Prototype</h4><p>Задает виды создаваемых объектов с помощью экземпляра прототипа и создает новые объекты путем копирования этого прототипа.</p><p><strong><em>Применимость</em></strong></p><ul><li>инстанцируемые классы определяются во время выполнения;</li><li>необходимость избежать параллельной иерархии классов или фабрик;</li><li>экземпляры могут находиться в одном из не очень большого числа состояний.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Prototype - определяет интерфейс для клонирования самого себя;</li><li>Concrete Prototype - реализует операцию клонирования себя;</li><li>Client - создает новый объект, обращаясь к прототипу с запросом клонировать себя.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37600f8860325ec3b3216a8ba770672a/href">https://medium.com/media/37600f8860325ec3b3216a8ba770672a/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>добавление и удаление продуктов во время выполнения;</li><li>спецификация новых объектов путем изменения значений;</li><li>спецификация новых объектов путем изменения структуры;</li><li>уменьшение числа подклассов;</li><li>динамическое конфигурирование приложения классами.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>сложно клонировать составные объекты, имеющие ссылки на другие объекты.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6igPH59aWY2VivbfwzPPKQ.png" /></figure><h4>Синглтон</h4><p>Этот паттерн гарантирует, что у класса есть только один экземпляр.</p><p><strong><em>Применимость</em></strong></p><ul><li>должен быть ровно один экземпляр класса, доступный всем клиентам;</li><li>единственный экземпляр должен расширяться путем порождения подклассов.</li></ul><p><strong><em>Участники</em></strong></p><ul><li>Singleton - определяет операцию instance, которая позволяет клиентам получать доступ к единственному экземпляру, может нести ответственность за создание собственного уникального экземпляра.</li></ul><p><strong><em>Реализация</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/33c33c1be1a43cb4530c81f310ee720e/href">https://medium.com/media/33c33c1be1a43cb4530c81f310ee720e/href</a></iframe><p><strong><em>Плюсы</em></strong></p><ul><li>контролируемый доступ к единственному экземпляру;</li><li>уменьшение числа имен;</li><li>допускает уточнение операций и представления;</li><li>допускает переменное число экземпляров.</li></ul><p><strong><em>Минусы</em></strong></p><ul><li>глобальные объекты могут быть привести к созданию не масштабируемого проекта;</li><li>усложняет написание тестов.</li></ul><p>В следущий раз мы поговорим о структурных паттернах ✌️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=536c4b001e06" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-sbermarket-blog/gof-on-ruby-1-536c4b001e06">GoF on Ruby # 1</a> was originally published in <a href="https://medium.com/tech-sbermarket-blog">tech.sbermarket.blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RubyRussia 2018]]></title>
            <link>https://medium.com/tech-sbermarket-blog/rubyrussia-2018-f86830f066c5?source=rss----6cc8f7d7d78c---4</link>
            <guid isPermaLink="false">https://medium.com/p/f86830f066c5</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[hr]]></category>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[hrtech]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Команда Разработки]]></dc:creator>
            <pubDate>Mon, 26 Nov 2018 14:07:51 GMT</pubDate>
            <atom:updated>2019-03-31T11:06:06.679Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8W8fiiyNw2J0uR7wfJW71A.jpeg" /></figure><p><em>Для ruby-компаний настали тяжёлые времена. Хотя рекрутеры и лиды повстанцев одержали первую победу над перегретым рынком и смогли привлечь в свои ряды сильных ruby-джедаев, HR война далека от завершения.</em></p><p><em>Избегая встречи с грозными джунами за 200, группа борцов за чистый код обустроила продвинутую рекрутинговую базу на отдаленной системе “Инстамарт”.</em></p><p>А теперь поехали:) Наш тимлид Паша выступил на конференции <a href="https://rubyrussia.club/">RubyRussia</a>, и мы с удовольствием делимся с вами записью выступления. Он рассказал о том, как мы сформировали сильную команду разработки и прокачиваем ее изо дня в день, о том как не потеряться на всех этапах подбора специалистов, и как нас благодарят провалившиеся кандидаты. Рассказали о нашем подходе к матрицам компетенций и планам развития, а также после выступления возглавили обсуждения по найму в рамках круглого стола. Было очень круто!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FZjd9LZ1PAIk%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DZjd9LZ1PAIk&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FZjd9LZ1PAIk%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/71e3eb5eb9edf4c906aa2e096a34223e/href">https://medium.com/media/71e3eb5eb9edf4c906aa2e096a34223e/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f86830f066c5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/tech-sbermarket-blog/rubyrussia-2018-f86830f066c5">RubyRussia 2018</a> was originally published in <a href="https://medium.com/tech-sbermarket-blog">tech.sbermarket.blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>