Кем ты был в прошлой жизни?
Кем ты был в прошлой жизни?
Во многих религиях считается, что мы проживаем не одну жизнь. И после смерти перерождаемся или в новом теле или в виде животного, растения и т. д. А из-за нашей природной любознательности мы периодически задаем себе вопрос: «Кем ты был в прошлой жизни?». Этот тест поможет вам найти ответ. Поговаривают, что его изобрел некий старец-отшельник, скитавшийся по горам Алтая 53 года, познавший тайны Шамбалы. А вот верить ли его результатам, решать вам. В любом случае пройти тест и узнать, кем были в прошлой жизни стоит. Отнеситесь к тесту с долей иронии и не забудьте поделиться результатами с друзьями.
Встроить на сайт
История
Насколько хорошо вы знаете историю России
Итоговый тест по истории для 5 класса
Хорошо ли вы знаете историю Второй мировой войны?
Итоговый тест по истории для 11 класса
Хорошо ли вы знаете историю Великой Отечественной войны?
Проверьте свои знания мифов Древней Греции
Итоговый тест по истории для 8 класса
Тест на гражданство
Итоговый тест по истории для 6 класса
Хорошо ли вы знаете Древний Египет?
Проходите тесты по истории онлайн, чтобы не просто проверить и закрепить свои знания, но и узнать что-то новое, благодаря показу правильных ответов после прохождения тестов. Хорошо ли вы знаете историю России и тайны дворцовых переворотов? А что насчет Всеобщей истории и правления Цезаря? Или мифология Древнего Египта и Древней Греции? Ответы на эти и многие другие вопросы помогут найти тесты по истории!
Проективный тест «Любовная история»
Жила-была молодая красивая девушка по имени Люба (). Пришло время и она влюбилась в красавца парня по имени Эдик (). Она знала, что и он страстно любит её, но любовь эта была «любовью на расстоянии», т.к. они жили по разным берегам широкой и бурной реки, которую не переплыть, а моста не было. Страдая от разлуки с любимым, Люба пошла вдоль реки, ища возможность переправиться на тот берег. Она встретила лодочника Петра () и рассказала ему о своей любви, о том, что она уже не в состоянии жить вдалеке от любимого и просила лодочника перевезти её на тот берег. Однако лодочник Петр сказал, что река широкая и бурная, и что он просто так перевозить её не будет – она должна заплатить за работу. У Любы не было денег, и она пошла вдоль берега, надеясь найти их у кого-нибудь. По дороге ей встретился прохожий Роман (), которому она тоже рассказала про свою любовь и о том, что если она достанет денег заплатить лодочнику за перевоз, то она встретиться со своим любимым. Прохожий Роман сказал, что деньги у него есть, но он ничего ей не даст, так как это её проблема. В расстроенных чувствах она вернулась к лодочнику Петру, надеясь всё же уговорить его. Но лодочник просто так не соглашался её перевозить. Подумав, он согласился её перевезти, если Люба даст ему всю свою одежду. Любе очень не хотелось этого делать, но, представив, что скоро она увидит своего любимого Эдика, она пошла на эту жертву. Она отдала всю свою одежду лодочнику, он перевез ее на другой берег. Стыдясь своей наготы, Люба, прячась за кустами, стала пробираться к Эдику. Но, ее увидел молодой парень (), о котором говорили, что будто бы он сексуальный маньяк. Увидев молодую, красивую, обнаженную девушку он возбудился, набросился на Любу и изнасиловал. Проходивший зарослями кустарника другой мужчина Олег () увидел это всё и рассказал об изнасиловании всем, в том числе и Эдику. Когда Люба наконец-то пришла к Эдику, на нее смотрели холодные глаза. «Я всё знаю», — сказал Эдик. «Прости, но я не смогу после всего этого любить тебя». Люба пошла обратно. Жизнь потеряла для нее смысл. Она бросилась в реку и утопилась. «Кто, по вашему мнению, наиболее виноват в случившейся трагедии? Напишите на листе бумаги первую букву его имени. Затем напишите первую букву имени того, чья степень вины, как вы считаете, находится на втором месте. И так далее, до того героя данной истории, кто, по вашему мнению, виноват меньше всего». Для анализа испытуемого психолог должен переписать полученный от испытуемого ранжированный ряд из шести героев истории, начиная с «наименее виновного», и закончив его «самым виновным». Наименее виновный указывает на наиболее доминирующую в психике испытуемого тенденцию. Энергия на её реализацию выделяется в первую очередь, в приоритетном порядке. Наиболее виноватый герой истории указывает на то стремление, которое не представляет для испытуемого никакой ценности. Поэтому на его реализацию энергия выделяется по так называемому «остаточному принципу». Соответствие героев истории и крайние значения доминирующих тенденций даны в Табл. 1. Принцип работы теста: выбирая из шести героев истории наиболее виноватого, испытуемый бессознательно выбирает ту тенденцию, от которой он сам отказался бы в первую очередь. Естественно, наиболее ценное для него стремление у него будет наименее виноватым.
Таблица 1. Факторы теста и их крайние значения
Таблица 2. Промежуточные значения факторов теста
Пример тестирования тестом «Любовная история». Девушка, 20 лет, студентка.
Характеристика:Стремление к замкнутости, к противопоставлению себя обществу.Стремится к гармонии собственных интересов с интересами окружающей его среды. Уступчив.Чувства и разум уравновешены. Любить способен, но выбор объекта любви слишком рационален и зависим от иных потребностей.Объективен и справедлив, но покладист. Ему трудно отказать в помощи тому, кто слаб, но имеет благородные цели.«Хочется» и «надо» для него синонимы. Его аппетиты может укротить лишь самая доминантная потребность. А это:Гиперпрагматизм и расчетливость до мелочности.
(вариант В. Джоса).
«А теперь, кто из оставшихся наиболее виноват?». И записываем первую букву его (её) имени во вторую клетку. И так далее, пока не занесём в таблицу всех восьмерых участников трагедии. Психологу же необходимо, поменяв буквы имён на символы факторов, записать их в нижеследующей таблице над номерами занимаемых позиций. Тем самым порядок ряда меняется на: от наименее виноватого до наиболее виноватого.
Таблица соответствия имён и факторов:
Расчёт индекса криминальности. Необходимо просуммировать баллы факторов е и hу и, отдельно, факторов k и р. Затем первую сумму разделить на вторую.
+ (баллы) + = ——————— = ————— = ——— = + (баллы) +
Если 1 < < 5 – склонность к преступному поведению. Если 0,2< < 1 – личность гуманизированная. Направленность: в будущее – в прошлое.
Не знаешь никаких сериалов, кроме турецких, и втайне мечтаешь о любви как у Серкана Болата и Эды Йылдыз? Тогда проходи наш тест и узнай, с кем из актеров тебе стоит встречаться.
Сегодня свой день рождения отмечает Джейкоб Элорди! Давай проверим, с кем из героев сериала ты могла бы встречаться. Проходи наш тест!
И давно тебе 17? Уже да. Вспоминаем современную «классику» и фантазируем, как бы устроили свою личную жизнь, окажись мы в вампирской саге.
Систему начали с нуля, писали на ASP.Net Web API, Entity Framework и AngularJs (Реакта и Vue тогда еще не было, дело было в далёком 2013), небольшой, но высокопрофессиональной командой, по Scrum, написали за 4 месяца первую базовую продакшн-версию с минимальным функционалом, впоследствии функционал постепенно наращивали, система развивается и по сей день. Через год после начала разработки, система уже была внедрена по всей компании и являлась business-critical, т.е. остановка системы даже на несколько часов могла повлечь довольно существенные убытки для компании.
Почему без юнит-тестов?
Бесспорно, юнит-тесты — очень хорошая штука. Прошу понять меня правильно, я ни в коем случае в этой статье не пытаюсь сказать что они не нужны или их не надо писать. Нужны. И надо.
Но с ними, нужно это понимать, немало тонкостей. Во-первых, конечно нужно, чтобы тесты писали грамотные квалифицированные люди, понимающие как это работает: иначе тесты начинают усложняться, проверять не то и не так, давать ложное чувство уверенности и т.д. Но наверное еще более важно, что тесты хорошо подходят не для всех возможных случаев.
Вот и тесты такие же на мой взгляд — да, есть случаи, когда автоматические тесты подходят идеально: например, если реализуешь какой-нибудь протокол, или пишешь компилятор, или библиотеку со строго заданным API и прочее. В таких случаях есть четкие требования и они описаны на низком уровне — и тесты работают замечательно. А по TDD такие проекты делать и вовсе сплошное удовольствие.
Если не юнит-тесты, то что?
На удивление, способов обеспечения качества ПО, помимо автоматических и ручных тестов, немало! Жалко и обидно, что они настолько недооценены, и о них мало кто говорит. Вот посмотришь хабр: тесты, тесты, тесты. Качество софта = всегда только тесты. И все, как будто нет альтернатив. Но ведь это не так: альтернативы есть, и в ряде случаев они подходят гораздо лучше.
В свое время меня эта тема очень интересовала и я изучал самые разнообразные методы. Интересовался, например, как делают космическое ПО, где одна ошибка может повлечь многомиллионные убытки. Наверное многим известно, что там используются такие супер-тяжелые методы, как формальная верификация, тотальное документирование, перекрестное тестирование независимыми командами тестеровщиков и прочее. Но оказывается, есть у них на вооружении и более дешевые средства (подробнее об этом ниже).
Другим «источником вдохновения» стал Брет Виктор, автор множества потрясающих концептов, и в том числе идеи Seeing spaces, и особенно той ее части (начиная примерно с 3:53 на видео), где речь идет о способах расследования и предотвращения багов. Идея в том, что для того, чтобы понять, что происходит внутри системы, нужно как бы «развернуть» эту систему, заглянуть внутрь, визуализировать ее во всех возможных плоскостях, увидеть как она работает изнутри. Если хорошо понимать, как работает система — то многих ошибок можно избежать. Здесь кстати снова пересечение с космической темой: это получается этакий локальный «Центр Управления Полетами» для данной системы.
(картинка взята отсюда: vimeo.com/97903574)
В свое время идея Брета меня совершенно захватила и наверное неделю я пытался придумать способ «развернуть» нашу конкретную систему, пока наконец-то не слепил из подручных средств утилитку-монитор, визуализирующий как минимум некоторые процессы происходящие внутри и позволяющий как бы заглянуть «под капот» системы. Эта утилитка впоследствии сэкономила мне много часов, позволила избежать кучи ошибок на ранней стадии, а в нескольких случаях — понять детально, что происходит на продакшене.
Безусловно, в современном вебдеве это решается с помощью логов, трейсинга (OpenTelemetry) и мониторинга, но многие успешные компании в добавление к этим вещам имеют свои собственные, специализированные утилиты, заточенные под визуализацию этого конкретно решения.
Кроме этих вещей, были недели поисков в гугле, десятки прочитанных статей, множество опробованных подходов и утилит, и конечно многие часы работы над кодом. Забегая вперед, одним из главных открытий для меня стал метод «fault tree analysis», но были и другие очень важные вещи. Всё это в совокупности позволило получить надежную и стабильную систему без юнит-тестов и тестировщиков.
«Космический» подход
Как пишут код, в котором не должно ошибок вообще? Ответ разочаровывающий: пишут его нудно и долго. Страшная бюрократия, документации больше чем кода и т.д. Никакого Scrum’а. И все же есть-таки чему поучиться и что позаимствовать у космического ПО!
Давайте рассмотрим последние два пункта немного подробнее.
Статический анализ
Статический анализ выглядит привлекательно: позволяет отловить кучу проблем и дешево.
Кстати, самый простой тип статического анализа — это intellisense, то, что мы каждый день используем в IDE (ну и компиляция кода, как частный случай). Очень важно, чтобы ваш проект полностью покрывался интеллисенсом. Например, если не использовать Entity Framework, а писать
stored procedures, то вероятность сделать ошибку при очередном рефакторинге резко возрастает.
Кроме стандартного intellisense, есть, конечно же, линтеры, такие как Stylecop или более современные и продвинутые, типа SonarQube.
А если хочется написать что-то совсем кастомное, заточенное под конкретный проект (и мне кажется, это очень даже полезно делать), то в C# есть ещё даже более крутая штука: Live Code Analyzers!
Live Code Analyzers
Начиная с Visual Studio 2015, с появлением Roslyn, были добавлены Live Code Analyzers — статические анализаторы кода, которые запускаются в IDE по мере создания кода. Иными словами, простая и доступная возможность создать кастомный intellisense.
В Live Code Analyzer есть доступ ко всему, с чем работает компилятор: лексическая свертка, AST, результаты семантического разбора. Можно комплексно анализировать код и обнаруживать довольно сложные ошибки.
В этой статье не хочется погружаться слишком глубоко в Code Analyzers, но давайте рассмотрим хотя бы вот такой простой пример — обнаружить все методы в solution больше 100 строк:
Полный код класса анализатора
Как видите, все довольно просто. Некоторое количество обвязки, но сама проверка — буквально одна строка. Впрочем, более полезные проверки потребуют, конечно, намного больше кода.
Основная проблема со статическими анализаторами, это то, что они имеют некоторый потолок по сложности проверок. Дальше этого потолка код анализаторов становится слишком сложным.
Например, мне удалось создать анализатор, который ругается, если поместить запрос к БД за пределы методов Web API контроллера (чтобы работа с БД не размазывалась по всему решению, поскольку очень часто проблемы с производительностью возникают после того, как кто-нибудь использует метод, дергающий базу данных в цикле).
Вывод: Статический анализ применим и вполне актуален, однако решает лишь часть проблемы — позволяет избежать низкоуровневых, технических багов, но редко когда может помочь с логическими ошибками.
Простой код
Простой код — это самый надежный способ борьбы с логическими ошибками. Простой, понятный, лаконичный код — это прекрасно! Но непросто.
Блоггеры и докладчики меня поймут: вот пишешь статью, или готовишь доклад, и хочется привести пример, который был бы одновременно и простым, и полезным. И вот на то чтобы изобрести такой пример, несколько дней может уйти (и еще не факт что придумаешь в итоге)! Найти те заветные 20 строчек кода, которые хорошо бы демонстрировали идею, делали бы что-то действительно полезное, и были бы простыми и понятными при этом — на практике оказывается очень нелегко.
Создание простого кода — это сложная задача, требующая глубоких знаний и большого количества времени.
Есть по этому поводу знаменитая цитата от Blaise Pascal (перевод с французского):
Это письмо получилось таким длинным потому, что у меня не было времени написать его короче.
И в этой цитате, безусловно, — очень много правды!
Вот какие подходы и методы лично я использую (весьма успешно) для создания простого кода:
Давайте рассмотрим их подробно.
Инкрементный рефакторинг
Термин мой собственный, выдуманный. Может быть это как-то по-другому официально называется. Но для меня — это просто то, как я пишу код, уже много лет, и весьма успешно.
Если грубо, идея заключается в том, чтобы не создавать детальную архитектуру кода проекта заранее. Накидали план в общих чертах, — и поехали. Как только какой-то класс или метод разрастается слишком сильно — ага, пора рефакторить. Видим, что слишком много контроллеров — ага, пора делать новый микросервис. И так далее. Таким образом, проект растёт инкрементно и «натурально», именно в тех местах, в которых действительно нужно.
Замечание: архитектура — понятие многогранное, здесь и далее я говорю именно про архитектуру кода — т.е. про то, как правильно структурировать проект, разбить на компоненты, сущности, файлы, классы и т.д.
Во-первых, такой подход прекрасно работает с заказчиком, который вначале проекта чётко не знает, чего хочет (т.е. с почти любым заказчиком). Во-вторых, нарисовать идеальную архитектуру для сложного проекта с первого раза в любом случае невозможно, в процессе обычно всплывает много такого, о чем на стадии планирования даже не задумывались.
Так что обычно все равно архитектуру приходится ревизить. Но если она была предварительно кропотливо создана, потрачено на это много времени и сил, то обычно совсем не хочется отказываться от сделанных раньше решений, и есть некое подсознательное желание все-таки впихнуть проект в старую архитектуру. А подсознание штука опасная, ему подчиняешься не думая. В общем, к добру это не приводит.
В итоге получается, что в изначально неправильную архитектуру пытаются впихнуть уже совершенно другое решение, городя в итоге кучу костылей и создавая очень сложный для понимания и дальнейшего развития код.
Поэтому, исходя из моего опыта, лучше совсем уж кропотливо ничего не планировать, а планировать только в общих чертах, и «открывать» детали архитектуры уже по мере создания проекта. Для этого, конечно, необходимы две вещи:
Я использую простой threshold, состоящий из двух условий:
При таком подходе архитектура строится соответственно росту проекта, и архитектурно продумываются именно те части проекта, которые растут и следовательно являются самыми важными и востребованными.
Правильная архитектура автоматически ведет к более простому коду.
Простые оптимизации
Когда программисты сталкиваются с проблемами с производительностью, они начинают оптимизировать код. Частенько настоящую проблему поймать довольно сложно, поскольку она происходит только на продакшене, который так просто не подебажить. Так что оптимизируется всё что только можно, и по максимуму.
У нас был в случай, когда человек, не очень хорошо разбиравшийся в MS SQL, «соптимизировал» систему путем перевода почти всех запросов к БД с Entity Framework на stored procedures. Потом пришлось переводить обратно, потому что поддерживать T-SQL код, не покрытый интеллисенсом, довольно сложно (повторюсь, речь о бизнес-проекте, требования меняются постоянно, а с ними вместе и модель базы данных). Да, и к слову, перевод на stored procedures оказался бессмысленным — проблем это не решило. Решение было в добавлении индексов и предпросчёта.
К чему веду: очень легко переусердствовать с оптимизациями. Код при этом очень сильно усложняется, и соответственно сложнее становится избежать багов. Везде нужен компромисс, также и с оптимизациями.
Например, если выяснилось, что Entity Framework генерирует неоптимальный запрос, или не умеет генерировать запрос который вам нужен, это не повод переходить на хранимые процедуры. Покрутите проблему в голове, почитайте умные статьи, решение всегда найдётся. В частности, сложные T-SQL запросы это в любом случае зло — так что и не нужно пытаться их генерировать. Вместо этого, например, вытащите данные по отдельности простыми запросами и склейте их в памяти.
Вообще, 90% проблем с производительностью БД на средних объемах данных и не супер высокой нагрузке решаются пятью простыми способами:
Для абсолютного большинства обычных проектов, этого достаточно. И даже в сложных проектах с Big Data и с миллионами пользователей онлайн, дальше оптимизировать нужно только наиболее нагруженные участки системы.
Мораль: Когда чините производительность, не увлекайтесь, а то сломаете себе
Fault tree analysis
Fault tree analysis — это по сути, просто метод для поиска возможных отказов, но его действенность, сложно переоценить.
Итак, для начала, уточняем у заказчика: какие части системы не должны отказывать ну ни при каких условиях, какие страницы наиболее критичны?
И дальше начинаем с этих страниц, и думаем: что может привести к тому, что страница не будет работать? И как это можно решить?
Например, примерно так я анализировал одну из критических страниц нашего сервиса — страницу со списком заданий и водителей, которая отображалась на InfoTV:
И так далее, для каждого из пунктов пытаемся найти возможные решения, или спускаемся ниже и смотрим какие могут быть причины — и пытаемся найти решения для них. В общем идея в том, чтобы иерархически проанализировать все возможные причины отказа.
На самом деле, пример упрощён: анализ критичных областей должен быть очень детальным. Нужно буквально смотреть на каждую строчку кода, и смотреть, при каких обстоятельствах она может упасть. Учитывать всё: потерю связи, пожар в дата-центре и т.д.
Что хочу сказать про fault tree analysis: несмотря на то, что более-менее все архитекторы знают про reliability, про то, как его улучшать, но оценку проблем, как правило, проводят очень ситуативно, бессистемно, часто пытаясь применить обобщенное решение (что работает довольно плохо). Например, я работал в двух больших Unicorn-ах, и даже там подход к reliability всё ещё бессистемный, и только в Big Tech этим уже занимаются серьёзно.
Fault tree analysis позволяет сконцентрироваться на действительно критичных участках и провести полный, системный анализ возможных отказов на этих участках. Если вы так ещё не делаете — попробуйте, это действительно круто работает!
Maintainability Index
Предположим, что мы проанализировали возможные отказы, улучшили код, и всё стало хорошо! Но ведь код имеет свойство постоянно меняться, практически жить своей жизнью. Изменения могут быть небольшими, но постоянными, и на code review, когда ты видишь только diff, бывает нелегко оценить суммарную получившуюся сложность всего метода в целом.
И вот здесь, для поддержания кода в хорошем состоянии, очень хорошо подойдёт вычисление метрик кода, таких как Cyclomatic Complexity — это отлично умеет делать Visual Studio для C#, да и для других языков полно утилит, которые умеют это делать.
В Visual Studio основные метрики суммируются в характеристике под названием Maintainability Index (от 0 — совершенно невозможно этот код поддерживать, до 100 — очень легко поддерживать), а полный набор отображаемых метрик выглядит примерно так:
Строится дерево по всему решению, дерево можно развертывать и искать конкретные классы и методы, где все плохо. Это, даже без fault tree analysis, — первые кандидаты на рефакторинг, особенно если они относятся к важным частям системы.
Интересный факт: когда мы впервые вычислили метрики кода нашего решения, самое худшее качество кода было в самом главном, самом критическом методе всей системы (который если упадёт — то всё, это «full stop»). И я уверен, что такой феномен — совсем не редкость.
В итоге, мы потратили наверное целый человеко-спринт 🙂 на то, чтобы этот метод переписать и максимально упростить.
Заключение и выводы
Это довольно старая история, но всё ещё очень актульная. С тех пор, например, я основал свой стартап, ему уже 5 лет, десятки клиентов (B2B), десятки тысяч пользователей, и ни одного теста. Несмотря на кучу pivot-ов и глобальных рефакторингов, очень стабильная система, и я в состоянии поддерживать и развивать её в одиночку.
Конечно, с тестами было бы ещё лучше, ещё надежнее, — в идеале, все возможные способы улучшения надежности ПО должны использоваться в комбинации друг с другом.
Но в этой статье я хотел обратить внимание на то, что все эти «второстепенные» способы, на самом деле дают удивительно хороший результат, и могут использоваться даже без тестов. О них мало кто пишет, мало кто считает их серьезным подспорьем для улучшения надежности ПО. А зря, на самом деле, они отлично работают!
Вы неправильно ответили на следующие вопросы:
Статистика
Рассказываем, что статистики и социологи знают о россиянах: как живут, чем болеют, что покупают, кем работают, сколько зарабатывают и тратят
