{ "version": "https:\/\/jsonfeed.org\/version\/1", "title": "Блог Корейши Виктора, posts tagged: программирование", "home_page_url": "https:\/\/koreysha.ru\/?go=tags\/programmirovanie\/", "feed_url": "https:\/\/koreysha.ru\/?go=tags%2Fprogrammirovanie%2Fjson%2F", "icon": "https:\/\/koreysha.ru\/user\/userpic@2x.jpg", "author": { "name": "Корейша Виктор", "url": "https:\/\/koreysha.ru\/", "avatar": "https:\/\/koreysha.ru\/user\/userpic@2x.jpg" }, "items": [ { "id": "28", "url": "https:\/\/koreysha.ru\/?go=all\/skolko-chelovek-delayut-sayt-prodolzhenie\/", "title": "Сколько человек делают сайт: продолжение", "content_html": "

Писал как-то полу-шуточную заметку о том сколько программистов оптимально для проекта<\/a>. Оказывается не меня одного волнует эта тема. Вот вариант ответа на этот вопрос от commitstrip.com<\/p>\n

\n\"\"\n<\/div>\n", "date_published": "2016-07-04T14:27:40+05:00", "date_modified": "2016-07-04T14:28:22+05:00", "image": "https:\/\/koreysha.ru\/pictures\/1466261845122291044.jpg", "_date_published_rfc2822": "Mon, 04 Jul 2016 14:27:40 +0500", "_rss_guid_is_permalink": "true", "_rss_guid": "https:\/\/koreysha.ru\/?go=all\/skolko-chelovek-delayut-sayt-prodolzhenie\/", "_e2_data": { "is_favourite": false, "links_required": [], "og_images": [ "https:\/\/koreysha.ru\/pictures\/1466261845122291044.jpg" ] } }, { "id": "27", "url": "https:\/\/koreysha.ru\/?go=all\/pochemu-ya-ne-lyublyu-bitriks\/", "title": "Почему я не люблю Битрикс", "content_html": "

Почему-то существует огромный пласт клиентов, максимально лояльных к Битриксу. Настолько, что они готовы переплатить только, что бы их сайт был на нем сделан. Так получилось, что я ни разу не писал сайты на Битриксе с 0, но мне часто приходилось их поддерживать и развивать.
\nНе знаю, дело в моем везении или в чем-то другом, но каждый раз в таком проекте код максимально плохой. Почему-то, всегда логика запихана в представление и наоборот. Так написано в официальный гайдах Битрикса?<\/p>\n

\n\"\"\n<\/div>\n

А вот сегодня, например, была банальная задача — подправить верстку. Вроде, ничего экстраординарного. Но где находится эта верстка в проекте найти не удавалось никак. В итоге путь получился примерно такой:<\/p>\n

\/bitrix\/templates\/template.main\/components\/ma\/catalog\/template1\/ma\/catalog.element\/.default\/<\/p>\n

И в этой папке лежал и HTML и CSS и, даже, картинки. «Джентельменский набор» для отображения одного из блоков на странице. Все остальная верстка лежала вообще не там. Но самая жесть, присмотритесь — скрытая диррректория. По умолчанию в Linux, если название начинается с точки, то фаил или папке не отображаются. И, разумеется, не синхронизируются с IDE<\/a>.<\/p>\n

Что заставило разработчиков сделать именно так? Не надо так.<\/p>\n", "date_published": "2016-05-20T18:04:32+05:00", "date_modified": "2016-05-20T18:04:23+05:00", "image": "https:\/\/koreysha.ru\/pictures\/nobitrix.jpg.png", "_date_published_rfc2822": "Fri, 20 May 2016 18:04:32 +0500", "_rss_guid_is_permalink": "true", "_rss_guid": "https:\/\/koreysha.ru\/?go=all\/pochemu-ya-ne-lyublyu-bitriks\/", "_e2_data": { "is_favourite": false, "links_required": [], "og_images": [ "https:\/\/koreysha.ru\/pictures\/nobitrix.jpg.png" ] } }, { "id": "23", "url": "https:\/\/koreysha.ru\/?go=all\/bstraktnaya-fabrika-i-primesi-v-php-chast-2\/", "title": "Абстрактная фабрика и примеси в PHP (Часть 2)", "content_html": "

Первая часть<\/a><\/p>\n

\n\"\"\n<\/div>\n

Однако, вернемся к нашему случаю. Допустим тут в комнату входит начитанный разработчик (НР), смотрит на код и вспоминает, что по условиям игры все светлые умеют лечить, а все темные становятся невидимыми. Добавим соответствующие методы.<\/p>\n

<?php\r\n\r\nabstract<\/span> class<\/span> Infantry<\/span> {\r\n    \/\/общие для всей пехоты методы<\/span>\r\n    abstract public <\/span>function<\/span> Attack<\/span>();\r\n    abstract public <\/span>function<\/span> Defend<\/span>();\r\n}\r\nabstract<\/span> class<\/span> Archer<\/span> {\r\n    abstract public <\/span>function<\/span> Shoot<\/span>();\r\n}\r\nabstract<\/span> class<\/span> SiegeWeapons<\/span> {\r\n    abstract public <\/span>function<\/span> Fire<\/span>();\r\n}\r\n\r\nclass<\/span> GoodInfantry<\/span> extends<\/span> Infantry<\/span> {\r\n    \/\/Спецэфическая реализация для доброго пехотинца<\/span>\r\n    public <\/span>function<\/span> Attack<\/span>();\r\n    public <\/span>function<\/span> Defend<\/span>();\r\n    \r\n    public <\/span>function<\/span> Treat<\/span>();\r\n}\r\nclass<\/span> GoodArcher<\/span> extends<\/span> Archer<\/span>{\r\n    public <\/span>function<\/span> Shoot<\/span>();\r\n    \r\n    public <\/span>function<\/span> Treat<\/span>();\r\n}\r\nclass<\/span> GoodSiegeWeapons<\/span> extends<\/span> SiegeWeapons<\/span>{\r\n    public <\/span>function<\/span> Fire<\/span>(); \r\n    \r\n    public <\/span>function<\/span> Treat<\/span>();\r\n}\r\n\r\nclass<\/span> EvilInfantry<\/span> extends<\/span> Infantry<\/span>{\r\n    \/\/Спецэфическая реализация для злого пехотинца<\/span>\r\n    public <\/span>function<\/span> Attack<\/span>();\r\n    public <\/span>function<\/span> Defend<\/span>();\r\n    \r\n    public <\/span>function<\/span> Invisible<\/span>();\r\n}\r\nclass<\/span> EvilArcher<\/span> extends<\/span> Archer<\/span>{\r\n    public <\/span>function<\/span> Shoot<\/span>();\r\n    \r\n    public <\/span>function<\/span> Invisible<\/span>();\r\n}\r\nclass<\/span> EvilSiegeWeapons<\/span> extends<\/span> SiegeWeapons<\/span>{\r\n    public <\/span>function<\/span> Fire<\/span>();\r\n    \r\n    public <\/span>function<\/span> Invisible<\/span>();\r\n}\r\n\r\nabstract<\/span> class<\/span> AbstractFactory<\/span>\r\n{\r\n    abstract public <\/span>function<\/span> createInfantry<\/span>();\r\n    abstract public <\/span>function<\/span> createArcher<\/span>();\r\n    abstract public <\/span>function<\/span> createSiegeWeapons<\/span>();\r\n}\r\n\r\nclass<\/span> GoodFactory<\/span> extends<\/span> AbstractFactory<\/span>\r\n{\r\n    \/**\r\n     * @return<\/span> Infantry\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createInfantry<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodInfantry<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> Archer\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createArcher<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodArcher<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> SiegeWeapons\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createSiegeWeapons<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodSiegeWeapons<\/span>();\r\n    }\r\n}\r\n\r\nclass<\/span> EvilFactory<\/span> extends<\/span> AbstractFactory<\/span>\r\n{\r\n    \/**\r\n     * @return<\/span> Infantry\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createInfantry<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilInfantry<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> Archer\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createArcher<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilArcher<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> SiegeWeapons\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createSiegeWeapons<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilSiegeWeapons<\/span>();\r\n    }\r\n}\r\n<\/pre>\n
Код стал не таким красивым по тому, что появились методы, которые приходится копировать. В php нет множественного наследования и приходится выбирать наследоваться белому лучнику от белых или от лучников. Мы априори выбрали второй вариант и теперь думаем, как сделать наш код красивее, а его поддержку удобнее. НР предлагает использовать примеси (trait), которые появились в php 5.4. Вынесем обшие методы в примесь.<\/p>\n
<?php\r\n\r\nabstract<\/span> class<\/span> Infantry<\/span> {\r\n    \/\/общие для всей пехоты методы<\/span>\r\n    abstract public <\/span>function<\/span> Attack<\/span>();\r\n    abstract public <\/span>function<\/span> Defend<\/span>();\r\n}\r\nabstract<\/span> class<\/span> Archer<\/span> {\r\n    abstract public <\/span>function<\/span> Shoot<\/span>();\r\n}\r\nabstract<\/span> class<\/span> SiegeWeapons<\/span> {\r\n    abstract public <\/span>function<\/span> Fire<\/span>();\r\n}\r\n\r\ntrait<\/span> Good<\/span> {\r\n    public <\/span>function<\/span> Treat<\/span>();\r\n}\r\n\r\ntrait<\/span> Evil<\/span> {\r\n    public <\/span>function<\/span> Invisible<\/span>();\r\n}\r\n\r\nclass<\/span> GoodInfantry<\/span> extends<\/span> Infantry<\/span> {\r\n    use<\/span> Good<\/span>;\r\n    \r\n    \/\/Спецэфическая реализация для доброго пехотинца<\/span>\r\n    public <\/span>function<\/span> Attack<\/span>();\r\n    public <\/span>function<\/span> Defend<\/span>();\r\n}\r\nclass<\/span> GoodArcher<\/span> extends<\/span> Archer<\/span>{\r\n    use<\/span> Good<\/span>;\r\n    public <\/span>function<\/span> Shoot<\/span>();\r\n}\r\nclass<\/span> GoodSiegeWeapons<\/span> extends<\/span> SiegeWeapons<\/span>{\r\n    use<\/span> Good<\/span>;\r\n    public <\/span>function<\/span> Fire<\/span>();\r\n}\r\n\r\nclass<\/span> EvilInfantry<\/span> extends<\/span> Infantry<\/span>{\r\n    use<\/span> Evil<\/span>;\r\n    \r\n    \/\/Спецэфическая реализация для злого пехотинца<\/span>\r\n    public <\/span>function<\/span> Attack<\/span>();\r\n    public <\/span>function<\/span> Defend<\/span>();\r\n}\r\nclass<\/span> EvilArcher<\/span> extends<\/span> Archer<\/span>{\r\n    use<\/span> Evil<\/span>;\r\n    public <\/span>function<\/span> Shoot<\/span>();\r\n}\r\nclass<\/span> EvilSiegeWeapons<\/span> extends<\/span> SiegeWeapons<\/span>{\r\n    use<\/span> Evil<\/span>;\r\n    public <\/span>function<\/span> Fire<\/span>();\r\n}\r\n\r\nabstract<\/span> class<\/span> AbstractFactory<\/span>\r\n{\r\n    abstract public <\/span>function<\/span> createInfantry<\/span>();\r\n    abstract public <\/span>function<\/span> createArcher<\/span>();\r\n    abstract public <\/span>function<\/span> createSiegeWeapons<\/span>();\r\n}\r\n\r\nclass<\/span> GoodFactory<\/span> extends<\/span> AbstractFactory<\/span>\r\n{\r\n    \/**\r\n     * @return<\/span> Infantry\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createInfantry<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodInfantry<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> Archer\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createArcher<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodArcher<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> SiegeWeapons\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createSiegeWeapons<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodSiegeWeapons<\/span>();\r\n    }\r\n}\r\n\r\nclass<\/span> EvilFactory<\/span> extends<\/span> AbstractFactory<\/span>\r\n{\r\n    \/**\r\n     * @return<\/span> Infantry\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createInfantry<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilInfantry<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> Archer\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createArcher<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilArcher<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> SiegeWeapons\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createSiegeWeapons<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilSiegeWeapons<\/span>();\r\n    }\r\n}\r\n<\/pre>\n
Теперь, какой бы сложной не была реализация лечения и невидимости, нам придется написать еге всего один раз и править в едином месте. Про абстрактную фабрику и про примеси есть куча литературы, но я ни разу не видел их описание в одной статье. А тем временем, практически каждое использование этого паттерна приводит к необходимости введения общих методов и свойств для групп обьектов, которые мы разделили нашими фабриками.<\/p>\n
P.S. Мне очень хотелось бы услышать критику моего изложения общеизвестных вещей и моего варианта использования примесей от коллег. Я открыл для себя паттерны проектирования пару лет назад, но использовать их начал только сейчас.
\nИ если будут у кого-то вопросы, то с радостью попробую ответить.<\/p>\n",
            "date_published": "2016-03-22T10:29:41+05:00",
            "date_modified": "2016-03-22T10:29:29+05:00",
            "image": "https:\/\/koreysha.ru\/pictures\/sochinenie_dobro_i_zlo_2_1.jpg",
            "_date_published_rfc2822": "Tue, 22 Mar 2016 10:29:41 +0500",
            "_rss_guid_is_permalink": "true",
            "_rss_guid": "https:\/\/koreysha.ru\/?go=all\/bstraktnaya-fabrika-i-primesi-v-php-chast-2\/",
            "_e2_data": {
                "is_favourite": false,
                "links_required": [],
                "og_images": [
                    "https:\/\/koreysha.ru\/pictures\/sochinenie_dobro_i_zlo_2_1.jpg"
                ]
            }
        },
        {
            "id": "22",
            "url": "https:\/\/koreysha.ru\/?go=all\/bstraktnaya-fabrika-i-primesi-v-php-chast-1\/",
            "title": "Абстрактная фабрика и примеси в PHP (Часть 1)",
            "content_html": "
Существует очень много статей о различных инструментах программирования и практиках их применения. Не бывает боевых проектов, которые реализуют единственный шаблон проектирования или используют единственный инструмент. В реальных условиях всегда приходится миксовать знания и опыт.<\/p>\n
Мне хотелось бы описать связь между различными практиками программирования, которые я встречал в своих проектах. Если опыт будет удачным, то попробую сделать цикл подобных постов.<\/p>\n
\n\"\"\n<\/div>\n
#Джуниор-разработчик и игра
\nДопустим, мы хотим написать браузерную игру, в которой «добро» борется со «злом». Пусть у обеих сторон есть пехота, лучники и осадные орудия. Для начала посадим за IDE джуниора. Через некоторое время мы, скорее всего, увидим следуюшие классы:<\/p>\n
class GoodInfantry{}\r\nclass GoodArcher{}\r\nclass GoodSiegeWeapons{}\r\n\r\nclass EvilInfantry{}\r\nclass EvilArcher{}\r\nclass EvilSiegeWeapons{}\r\n<\/pre>\n
#Опытный разработчик и абстрактная фабрика<\/p>\n
Придет опытный разработчик (ОР) и скажет, что это же класика для шаблона проектирования «абстрактная фабрика». Шаблоны проектирования разбирали уже тысячи раз на различных языках, но все же я хочу сделать статью самодостаточной и опишу еще разок. Если вы знаете «банду четырех», как свои пять пальцев, то перейдите к следующему подзаголовку.<\/p>\n
ОР знает, что «добрая» сторона обязательно будет иметь свои особенности, отличные от «злой». При этом так же понятно, что пехота с обоих сторон так же будет иметь нечто общее. Таким образом каждый юнит фактически должен унаследовать какие-то свойства от своей стороны, а какие-то от своего типа.<\/p>\n
\n\"\"\n<\/div>\n
Для того чтобы система оставалась независимой от специфики той или иной стороны необходимо использовать общие интерфейсы для всех основных типов юнитов. Это означает, что необходимо использовать три абстрактных базовых класса для каждого типа воинов. Производные от них классы будут реализовывать специфику соответствующего типа воинов той или иной армии.<\/p>\n
Второй момент, который стоит учесть, связан с тем, что юнитов в игре будет много и создавать их будет не программист, а игрок. То есть программист не сможет просто прописать в коде нужное количество раз создание, допустим, пехотинца. Вместо этого он должен учесть создание пехотинца какой-то функцией. А, вспомнив, что мы находимся в концепции ООП, скорее методом какого-то более общего объекта. Допустим, что юнитов создает у нас «фабрика света» на «доброй» стороне и «фабрика тьмы» на «злой». Светлая фабрика будет выглядеть так:<\/p>\n
\n\"\"\n<\/div>\n
Вспомним так же, что все пехотинцы будут наследовать класс Infantry. И подумаем о том, что фабрики, вероятно, будут иметь одинаковый набор методов, а значит хорошо бы им унаследовать единый абстрактный класс. Такой подход гарантирует нам, что ОР, создав абстрактные классы может идти курить и доверить написание реализации джуниору, ведь любая ошибка в реализации будет сразу видна. То, что у нас получилось, фактически, и есть паттерн Абстрактная фабрика. стрелки без подписи «создает» обозначают наследование.<\/p>\n
\n\"\"\n<\/div>\n
Такая структура — пример хорошего кода для общего случая создания групп связанных обьектов. То есть всегда, когда у нас есть необходимость создавать экземпляры классов не в ручном режиме и когда у нас есть группы связанных объектов (в нашем случае все светлые и все темные связаны) паттерн подходит. Удобно то, что он раширяется, как горизонтально (можно добавлять еще стороны, кроме света и тьмы), так и вертикально без переписывания кода многократно.<\/p>\n
<?php\r\n\r\nabstract<\/span> class<\/span> Infantry<\/span> {\r\n    \/\/общие для всей пехоты методы<\/span>\r\n    abstract public <\/span>function<\/span> Attack<\/span>();\r\n    abstract public <\/span>function<\/span> Defend<\/span>();\r\n}\r\nabstract<\/span> class<\/span> Archer<\/span> {\r\n    abstract public <\/span>function<\/span> Shoot<\/span>();\r\n}\r\nabstract<\/span> class<\/span> SiegeWeapons<\/span> {\r\n    abstract public <\/span>function<\/span> Fire<\/span>();\r\n}\r\n\r\nclass<\/span> GoodInfantry<\/span> extends<\/span> Infantry<\/span> {\r\n    \/\/Спецэфическая реализация для доброго пехотинца<\/span>\r\n    public <\/span>function<\/span> Attack<\/span>();\r\n    public <\/span>function<\/span> Defend<\/span>();\r\n}\r\nclass<\/span> GoodArcher<\/span> extends<\/span> Archer<\/span>{\r\n    public <\/span>function<\/span> Shoot<\/span>();\r\n}\r\nclass<\/span> GoodSiegeWeapons<\/span> extends<\/span> SiegeWeapons<\/span>{\r\n    public <\/span>function<\/span> Fire<\/span>();\r\n}\r\n\r\nclass<\/span> EvilInfantry<\/span> extends<\/span> Infantry<\/span>{\r\n    \/\/Спецэфическая реализация для злого пехотинца<\/span>\r\n    public <\/span>function<\/span> Attack<\/span>();\r\n    public <\/span>function<\/span> Defend<\/span>();\r\n}\r\nclass<\/span> EvilArcher<\/span> extends<\/span> Archer<\/span>{\r\n    public <\/span>function<\/span> Shoot<\/span>();\r\n}\r\nclass<\/span> EvilSiegeWeapons<\/span> extends<\/span> SiegeWeapons<\/span>{\r\n    public <\/span>function<\/span> Fire<\/span>();\r\n}\r\n\r\nabstract<\/span> class<\/span> AbstractFactory<\/span>\r\n{\r\n    abstract public <\/span>function<\/span> createInfantry<\/span>();\r\n    abstract public <\/span>function<\/span> createArcher<\/span>();\r\n    abstract public <\/span>function<\/span> createSiegeWeapons<\/span>();\r\n}\r\n\r\nclass<\/span> GoodFactory<\/span> extends<\/span> AbstractFactory<\/span>\r\n{\r\n    \/**\r\n     * @return<\/span> Infantry\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createInfantry<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodInfantry<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> Archer\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createArcher<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodArcher<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> SiegeWeapons\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createSiegeWeapons<\/span>()\r\n    {\r\n        return<\/span> new<\/span> GoodSiegeWeapons<\/span>();\r\n    }\r\n}\r\n\r\nclass<\/span> EvilFactory<\/span> extends<\/span> AbstractFactory<\/span>\r\n{\r\n    \/**\r\n     * @return<\/span> Infantry\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createInfantry<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilInfantry<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> Archer\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createArcher<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilArcher<\/span>();\r\n    }\r\n\r\n    \/**\r\n     * @return<\/span> SiegeWeapons\r\n     *\/<\/span>\r\n    public <\/span>function<\/span> createSiegeWeapons<\/span>()\r\n    {\r\n        return<\/span> new<\/span> EvilSiegeWeapons<\/span>();\r\n    }\r\n}\r\n<\/pre>\n
Причем же тут примеси? Продолжение следует.<\/p>\n",
            "date_published": "2016-03-18T16:43:36+05:00",
            "date_modified": "2016-03-18T16:43:06+05:00",
            "image": "https:\/\/koreysha.ru\/pictures\/sochinenie_dobro_i_zlo_2.jpg",
            "_date_published_rfc2822": "Fri, 18 Mar 2016 16:43:36 +0500",
            "_rss_guid_is_permalink": "true",
            "_rss_guid": "https:\/\/koreysha.ru\/?go=all\/bstraktnaya-fabrika-i-primesi-v-php-chast-1\/",
            "_e2_data": {
                "is_favourite": false,
                "links_required": [],
                "og_images": [
                    "https:\/\/koreysha.ru\/pictures\/sochinenie_dobro_i_zlo_2.jpg",
                    "https:\/\/koreysha.ru\/pictures\/-.png",
                    "https:\/\/koreysha.ru\/pictures\/-_1.png",
                    "https:\/\/koreysha.ru\/pictures\/-_2.png"
                ]
            }
        },
        {
            "id": "20",
            "url": "https:\/\/koreysha.ru\/?go=all\/migracii-bazy-dannyh-v-web-razrabotke\/",
            "title": "Как я открыл для себя миграции",
            "content_html": "
Как правило, перенос сайта с одного сервера на другой состоит из двух этапов: перенос файлов и базы данных. Когда мы говорим о разработке и поддержке серьезного проекта, обычно, мы имеем несколько серверов с разными версиями. Например сервер разработки (DEV), сервер тестирования (TEST) и «боевой» (PROD). А иногда, по копии сайта  для каждого разработчика<\/a>.<\/p>\n
При такой схеме с двухфакторный перенос вызывает серьезные сложности. Во-первых, кто-то может не уследить и версия кода разойдется с версией базы данных, что может привести к сложно-обнаруживаемым багам и даже гейзенбагам<\/a>.
\nВо-вторых, обычно бывает так, что структура базы данных на сервере разработчиков поменялась при очередной итерации доработок, но и сами данные на «боевом сервере» обновились. А это значит, что нужно сначала слить актуальные данные и актуальную структуру, а только потом базу можно подключать. Я однажды при такой операции перепутал окошко консоли и удалил обновленную структуру данных. Возможности восстановить её автоматически не было и пришлось следующие несколько часов вносить изменения заново. В этот момент я был бы счастлив, если бы прочитал эту свою сегодняшнюю заметку.<\/p>\n
Решение, как все гениальное, кажется очевидным, когда ты его знаешь. Как избавится от двух этапов переноса? Сделать так, что бы один этап автоматически «подтягивал» второй. Например, хранить все изменения для БД в файловой системе. Благо, SQL нам в этом помогает очень сильно. Такие изменения назвали миграциями.<\/p>\n
Я впервые познакомился с механизмом миграций в CMS  yupe, на базе фраемворка Yii. По этому все, что напишу далее относится к этой конкретной реализации, хотя идея, в целом, остается неизменной везде.<\/p>\n
Итак, если мы хотим внести изменения в базу, то вместо того, что бы лезть туда руками, мы создаем скрипт, который знает что нужно делать для применения изменений и для их отмены. Например, для этого создается класс с двумя методами up(), который создает новую таблицу, и down(), который её удаляет. Все остальное, что ему нужно он наследует от системного класса.<\/p>\n
Далее, в системе есть способ (специальный скрипт), который для применения миграции создает объект этого класса и выполняет up, а для отмены down. Разумеется, в базе нам так же нужно хранить информацию о том, какие миграции к ней уже применились, а какие еще нет. Так же важен механизм очередности миграций, который так же зашит где-то в системе. Таким образом мы:<\/p>\n
    \n
  1. Всегда уверены в актуальности бд. Всегда точно знаем, что к ней уже применилось, а что еще нет.<\/li>\n
  2. Храним всю историю в системе контроля версий вместе со всей остальной историей разработки.<\/li>\n
  3. Можем в любой момент откатить не только состояние кода, но и базы данных к любому этапу.<\/li>\n
  4. Легко сливаем изменения от нескольких разработчиков. Теоретически, могут возникнуть конфликты, но на практике ни разу у меня не возникали.<\/li>\n<\/ol>\n
    Для того, что бы этот механизм принес максимум пользы, я выделил для себя ряд правил «гигиены».<\/p>\n
      \n
    1. Создавать всю базу с самого начала миграциями. Казалось бы, в начале разработки, до того, как сайт перекочует дальше с первого сервера разработки проблем, о   которых я писал в начале, не должно быть. Но, если уж начал делать миграции становится сложно остановиться. А серьезно, такое правило позволяет с самого начала делать все по одной схеме и не будет такого, что вот до этого момента мы можем посмотреть все изменения базы, а ранее она монолитна.<\/li>\n
    2. Стараться делать миграции с привязкой к коммитам. Идеально: одна задача — один коммит — одна миграция. Последней конечно может и не быть. Сами задачки при этом должны быть небольшими 1-4 часа.<\/li>\n
    3. При соблюдении предыдущего правила в название миграции хорошо бы включать id задачи. Но не ограничиваться только им, а написать еще и на человекопонятном языке.<\/li>\n<\/ol>\n",
            "date_published": "2016-03-13T12:12:22+05:00",
            "date_modified": "2016-03-13T12:11:49+05:00",
            "_date_published_rfc2822": "Sun, 13 Mar 2016 12:12:22 +0500",
            "_rss_guid_is_permalink": "true",
            "_rss_guid": "https:\/\/koreysha.ru\/?go=all\/migracii-bazy-dannyh-v-web-razrabotke\/",
            "_e2_data": {
                "is_favourite": false,
                "links_required": [],
                "og_images": []
            }
        },
        {
            "id": "19",
            "url": "https:\/\/koreysha.ru\/?go=all\/gikovskiy-sayt\/",
            "title": "Гиковский сайт",
            "content_html": "
      В блоге «Записки программиста»<\/a> нашел ссылку на суперминималистичный сайт Андрея Прокопюка<\/a>. Решил пофантазировать на тему, как можно сделать сайт еще более гиковским?<\/p>\n
      \n\"\"\n<\/div>\n
      Представляю вашему вниманию мою первую попытку<\/a>. Буду рад отзывам, замечаниям и предложениям.<\/p>\n",
            "date_published": "2016-03-03T14:48:05+05:00",
            "date_modified": "2016-03-03T14:47:48+05:00",
            "image": "https:\/\/koreysha.ru\/pictures\/_326.jpg",
            "_date_published_rfc2822": "Thu, 03 Mar 2016 14:48:05 +0500",
            "_rss_guid_is_permalink": "true",
            "_rss_guid": "https:\/\/koreysha.ru\/?go=all\/gikovskiy-sayt\/",
            "_e2_data": {
                "is_favourite": false,
                "links_required": [],
                "og_images": [
                    "https:\/\/koreysha.ru\/pictures\/_326.jpg"
                ]
            }
        },
        {
            "id": "18",
            "url": "https:\/\/koreysha.ru\/?go=all\/kak-my-vvodili-git\/",
            "title": "Как мы вводили git",
            "content_html": "
      Git — это одна из популярных систем контроля версий. Код — это, прежде всего, текст. Такой текст, который правят многократно и по чуть-чуть в разных местах. Хранить только последнюю версию кода не дальновидно, по тому, что часто какие-то правки приходится отменять, а в каких-то случаях надо посмотреть «как оно работало раньше». Хранить каждую новую версию кода, то есть копировать всю директорию, допустим раз в день, не удобно по двум причинам: во-первых, занимает много места, а во-вторых, не дает никакого понимания о том, что именно изменилось.
      \nУмные программисты придумали решение этих проблем. Оно заключается в том, что бы хранить какую-то базовую версию, а после сохранять только маску изменений. Например, мы храним 1000 строк кода и после изменений запоминаем, что поменялись 387 строка и 425.
      \nТакое решение дало еще один неожиданный плюс. Оно позволило работать над одним и тем же кодом разным людям одновременно. Первый программист поменял вторую, третью и четвертую строку, а второй — девятую и десятую. Система сама поняла, что может применить к начальному коду и те изменения и эти. И только, если возникнет конфликт, придется разруливать людям.<\/p>\n
      Америка<\/h2>\n
      Впрочем, если вы так или иначе связаны с разработкой программного обеспечения, скорее всего, Америку я вам не открыл. Во всем мире различные системы контроля версий — неотъемлемый атрибут любого программиста. Читая профессиональные форумы, блоги известных web-разработчиков и доклады с различных конференций сложно себе представить, что кто-то может жить без git-а или svn-а. Однако, в наших реалиях куча небольших веб студий и одиночек-фрилансеров работают «по-старинке». Так получилось, что и я на первых своих местах работы с системами контроля версий познакомился только заочно. До сих пор стыдно признаться, что несколько лет я писал код без таких систем.
      \nВпрочем, я был такой не один. И так получилось, что у нас собралась команда из четырех человек, где никто полноценно с контролем версий не работал. У меня был до этого опыт, где все настроили до меня и оставалось только коммитить, то есть записывать изменения которые я внес. Еще у двоих членов команды был подобный опыт. Однако никто из нас не представлял, как полностью должна работать система от компьютера программиста до «боевого сервера».<\/p>\n
      \n\"\"\n<\/div>\n
      Как ни странно, гугление не могло ответить на те вопросы, которые возникали у меня в первую очередь. Например гугл на вопрос «Как смержить ветки git<\/a>» дает около 700 результатов и вся первая страница по делу. А на запрос «git локально или на сервере<\/a>» дает 275 тыс ответов и я не смог найти что-то в тему.<\/p>\n
      Наши правила<\/h2>\n
      Многое мне было непонятно. Но в итоге чтения кучи статей и советов я принял ряд решений.<\/p>\n
        \n
      1. Мы отказались от гита локально на каждом компьютере разработчика. Вместо этого, мы используем IDE и копию проекта на нашем сервере. У каждого разработчика есть своя локальная копия и своя удаленная копия. Уже на сервере стоит гит и туда надо зайти что бы провести с ним какие-то операции. Такое решение я принял по целому ряду причин. Основная причина в том, что мы взяли курс на проекты выше среднего по сложности и настраивать у каждого разработчика веб-сервер с нужными пакетами в условиях разных ОС и различной удаленности друг от друга сложная задача. А внедрить все это надо было без ущерба для производства.<\/li>\n
      2. Никаких встроенных в IDE систем поддержки git и других «улучшителей вкуса» мы решили не использовать. Во-первых, в нативных командах из консоли нет ничего, чему нельзя научить за пару дней. А во-вторых, меня однажды такая система поддержки сильно подвела — вывела совсем не то, что произошло на самом деле.<\/li>\n
      3. Мы ввели правило одна задача — одна ветка. Коммитов в нее может быть много, но чаще 1-2. Сливаем изменения только после завершения задачи.<\/li>\n
      4. Все, что не касается напрямую нашего кода мы стараемся исключить из системы контроля версий. С этой задачей до сих пор справляемся хуже всего.<\/li>\n
      5. Ввели правило «сервера для тестирования». Каждый раз после сливания изменений от разных разработчиков сайт поступает на тестирование и только потом выходит в продакшн, как бы не торопил заказчик.<\/li>\n
      6. Мы стали использовать git в связке с Bitbucket. Система контроля версий без удаленного репозитория и в половину не так хороша. Но это, наверное, тема для отдельной заметки.<\/li>\n<\/ol>\n
        И все пошло, как по маслу?<\/h2>\n
        В начале было очень тяжко. Постоянно забывали новую схему работы и то вносили какие-то правки прямо на «живом сервере», то забывая про это пытались залить туда изменения с сервера разработки. Постоянно получали конфликты и не понимали, как их решать. Самое сложное было постоянно заставлять всех работать только через систему контроля версий. Каждый раз хотелось «сделать последний разок по-простому». И каждый раз приходилось останавливать и себя и команду.<\/p>\n
        С тех пор прошло уже достаточно много времени, и я теперь я с уверенностью могу сказать, что это было одно из самых правильных управленческих решений. Сколько раз спасала нас эта схема сложно описать. Сколько недовольства клиентов мы смогли избежать за счет аккуратного подхода к переносу на «боевой», трудно себе даже представить.<\/p>\n
        А какую систему контроля версий используйте вы? И какие сложности были с её внедрением?<\/p>\n",
            "date_published": "2016-01-15T22:10:04+05:00",
            "date_modified": "2016-01-15T22:09:38+05:00",
            "image": "https:\/\/koreysha.ru\/pictures\/git.png",
            "_date_published_rfc2822": "Fri, 15 Jan 2016 22:10:04 +0500",
            "_rss_guid_is_permalink": "true",
            "_rss_guid": "https:\/\/koreysha.ru\/?go=all\/kak-my-vvodili-git\/",
            "_e2_data": {
                "is_favourite": false,
                "links_required": [],
                "og_images": [
                    "https:\/\/koreysha.ru\/pictures\/git.png"
                ]
            }
        },
        {
            "id": "16",
            "url": "https:\/\/koreysha.ru\/?go=all\/router-kak-komponent-veb-sistemy-chast-1\/",
            "title": "Роутер, как компонент веб-системы. Часть 1.",
            "content_html": "
        Я продолжаю разбирать разные компоненты CMS. Предыдущие заметки по теме:<\/p>\n