- -
- 100%
- +
Авторское наблюдение
Когда я начала внимательнее смотреть на свою систему, то заметила одну вещь, которая долго ускользала от внимания. Материалы были аккуратно разложены, но я не всегда видела, как один из них ведет к другому. Из-за этого приходилось постоянно заново вспоминать, где именно находится продолжение темы, что уже сделано, а что только должно появиться. В какой-то момент я поняла, что мне нужна не просто удобная структура хранения, а способ видеть весь путь материала сразу. Именно тогда я впервые почувствовала разницу между архивом и системой. Архив хранит. Система связывает.
---------------------------------------------------------------------------------------------------------------------------Правило операционной системы:
Система должна не только хранить объекты, но и показывать связи между ними, включая связи внутри одного проекта.
Это правило очень логично продолжает все, что мы уже сформулировали раньше. Сначала мы поняли, что нельзя дублировать одну и ту же информацию в нескольких местах. Затем увидели, что система должна строиться вокруг объектов, а не вокруг папок. Теперь становится ясно, что одного объекта и его метаданных тоже недостаточно.
Если объекты не связаны между собой, система остается неподвижной. Связи делают ее живой. Благодаря им можно видеть происхождение материала, его продолжения, дополнительные форматы и место в общей структуре.
---------------------------------------------------------------------------------------------------------------------------Почему Obsidian подходит для этого особенно хорошо?Сейчас мы еще не переходим к технической части, но уже можем заметить, почему выбранная нами архитектура идеально соответствует возможностям Obsidian. В этой программе заметки умеют связываться друг с другом. Это значит, что объект может указывать на другой объект, а система - видеть эти связи как часть своей структуры.
Именно поэтому Obsidian так хорошо подходит для нашей задачи. Он не просто хранит информацию. Он позволяет строить из нее сеть. А сеть, в отличие от простого набора файлов, уже очень близка к настоящей операционной системе.
Но важно не перепутать порядок шагов. Сначала мы должны понять архитектуру. И только потом технические возможности программы смогут раскрыться в полной мере. Если начать с инструмента, легко потерять сам замысел. Если сначала понять структуру, любой инструмент будет подчиняться этой структуре, а не наоборот.
ПрактикаВозьмите любой из ваших материалов и попробуйте мысленно построить вокруг него карту. Не ограничивайтесь только тем, что лежит в самом документе. Подумайте, из чего он вырос и во что может превратиться. Например, у него может быть исходная идея, несколько исследовательских заметок, черновик сценария, запись, окончательный текст, короткий ролик, статья, материалы для подписчиков и итоговая аналитика. Все это не отдельные случайные элементы. Это части одного процесса, и именно так их нужно увидеть.
После этого попробуйте задать себе вопрос: какие из этих элементов действительно связаны между собой? Где один материал продолжает другой? Где один объект становится основой для нескольких других? Постарайтесь увидеть не просто список, а схему движения информации. Это очень простое упражнение, но именно оно помогает начать мыслить картой, а не набором отдельных документов.
Типичные ошибкиСамая распространенная ошибка на этом этапе - снова начать мыслить папками. Человек хочет построить карту, но вместо этого создает еще один раздел для «связанных материалов». Это не карта, а всего лишь новая полка.
Еще одна ошибка - считать, что связи нужны только для редких случаев. На практике именно связи делают систему полезной каждый день. Если они не заданы, человек снова вынужден полагаться только на память и ручной поиск.
Не менее опасно пытаться связать абсолютно все со всем. Тогда система перестает помогать и превращается в сложную паутину, в которой трудно разобраться. Нам нужна не максимальная сложность, а ясная логика. Поэтому связи должны быть только там, где они действительно отражают реальное отношение между объектами.
Проверьте себяПосле прочтения этой главы попробуйте ответить на несколько вопросов.
Можете ли вы объяснить, почему одного объекта и его метаданных еще недостаточно для полноценной системы? Понимаете ли вы, чем карта системы отличается от обычного списка материалов? Удается ли вам увидеть, как один материал может вести к нескольким другим?
Если на эти вопросы трудно ответить уверенно, лучше еще раз перечитать основную часть главы. Именно здесь формируется понимание того, как будет устроена вся будущая операционная система.
Итоги главыВ этой главе мы сделали еще один важный шаг. Мы поняли, что система должна не только хранить объекты и описывать их метаданными, но и показывать связи между ними. Именно связи превращают базу знаний в живую среду, в которой один материал может порождать другой, и позволят системе автоматически создавать дочерние материалы, публикации и задачи без ручного дублирования информации.
Мы также увидели, что карта системы - это не папка, не список и не декоративная схема. Это способ понять, как объекты взаимодействуют друг с другом. Без такой карты любая база знаний быстро превращается в набор изолированных файлов. С ней же система становится цельной и действительно удобной.
И наконец, мы зафиксировали следующее правило будущей операционной системы: система должна не только хранить объекты, но и показывать связи между ними. Именно это правило позволит нам в дальнейшем строить календарь, шаблоны, аналитику и все остальные элементы книги уже не как отдельные инструменты, а как части единой структуры.
Что дальшеТеперь, когда у нас есть объект, его метаданные и карта связей, можно переходить к следующему шагу. В следующей главе мы наконец начнем разбирать сам Obsidian как инструмент. Но теперь это уже будет не просто знакомство с программой, а осознанный переход к реализации той архитектуры, которую мы успели спроектировать.
Прежде чем двигаться дальше, попробуйте еще раз посмотреть на один свой материал и представить его не как отдельный документ, а как точку в сети. Куда он ведет? Откуда он появился? Во что превращается дальше? Если вы начинаете видеть именно так, значит мы движемся в правильном направлении.
Глава 5. Проектируем архитектуру операционной системы
Цель главыВ предыдущих главах мы постепенно разобрали то, без чего невозможно построить надежную систему. Сначала мы увидели, почему хаос возникает не из-за количества инструментов, а из-за дублирования информации. Затем поняли, что система должна строиться вокруг объектов, а не вокруг папок. После этого разобрались, зачем объектам нужны метаданные, и увидели, как между ними возникают связи, которые превращают набор заметок в живую структуру.
Теперь пришло время собрать все это в единую картину. В этой главе мы не будем еще раз возвращаться к отдельным понятиям по очереди. Наша задача гораздо важнее: спроектировать общую архитектуру операционной системы автора, чтобы стало ясно, как именно контент проходит путь от идеи до публикации и какие элементы системы участвуют в этом пути.
К концу главы вы увидите, как из отдельных объектов, правил и связей складывается целостная система, в которой основной контент порождает дочерние материалы, публикации, задачи и аналитику. Именно здесь начинает появляться тот самый фундамент, на котором позже будет строиться работа в Obsidian.
От отдельных элементов к единой системеДо этого момента мы специально разбирали систему по частям. Такой подход был необходим, потому что невозможно построить надежную архитектуру, если сначала не понять, из каких элементов она вообще состоит. Однако любая архитектура становится по-настоящему полезной только тогда, когда отдельные элементы начинают работать вместе.
Представьте себе мастерскую, в которой есть хорошие инструменты, прочные полки, удобный стол и отдельные коробки для хранения материалов. Все это полезно само по себе. Но если между ними нет логики, мастерская еще не стала рабочей системой. Она останется набором хороших, но разрозненных элементов.
С контентом происходит то же самое. Идея, сценарий, публикация, короткий ролик, статья могут быть отлично организованы по отдельности. Но до тех пор, пока они не подчинены общей архитектуре, они будут существовать как отдельные фрагменты работы, а не как единая операционная система. Именно поэтому нам важно не просто знать, что такое объект, метаданные и связи. Нам нужно понять, как все это соединяется в один непрерывный процесс. В этом и заключается главная задача текущей главы.
Что является центром системыКогда мы говорим об архитектуре, очень важно сразу определить, вокруг чего она строится. В нашей книге таким центром становится не папка, не календарь и не отдельная публикация. Центром системы является проект. Проект- это верхнеуровневая единица, внутри которой есть основной контент, а вокруг него постепенно возникают все остальные элементы. Именно проект объединяет разные части работы в одно целое. Он задает смысл, направление и границы.
Если смотреть на систему с этой точки зрения, становится понятно, почему одна и та же идея может порождать сразу несколько объектов. У проекта есть основной материал. Из него могут появиться дополнительные форматы. Один и тот же сюжет может превратиться в короткий ролик, статью, дополнительные публикации и так далее. Все это не случайные файлы. Это части одной общей архитектуры.
Такой подход особенно важен для автора, который работает сразу с несколькими площадками и форматами. В этом случае проект становится тем местом, где собирается вся работа по конкретной теме. Он позволяет видеть не только отдельные материалы, но и всю систему целиком.
У каждого автора свой основной тип контента. Для одного это видео, для другого - статья, для третьего - подкаст или другой формат. Поэтому проект всегда строится вокруг того основного материала, который является центром работы именно этого автора.
Один проект может порождать несколько связанных объектов, и именно это делает систему целостной.
Как проект превращается в рабочую структуруПроект сам по себе еще не является готовой системой. Он становится ею только тогда, когда у него появляются четкие правила жизни. Эти правила уже частично были сформулированы нами раньше, но теперь важно увидеть их как части одного механизма.
Сначала проект получает метаданные. Благодаря ним система понимает, что это за проект, к какому типу он относится, когда он должен выйти и какие дополнительные материалы с ним связаны. Потом у проекта появляются связи. Они показывают, какие дочерние материалы уже созданы, какие публикации запланированы, какие задачи еще нужно выполнить и где можно увидеть результат. После этого начинает работать жизненный цикл. Проект не просто лежит в системе. Он движется. Сначала появляется идея. Затем формируется основной материал. После этого начинают рождаться дополнительные форматы. Далее создаются публикации и задачи. Затем материал выходит на площадках. И только после этого система фиксирует результат в аналитике.
Когда все эти элементы соединяются, проект перестает быть абстрактной концепцией и становится реальной рабочей единицей. Именно тогда мы начинаем видеть не просто заметки, а структуру, которая может жить и развиваться сама.
Почему одной структуры недостаточноМожет показаться, что если мы уже определили проект, объект, метаданные и связи, то система почти готова. Но это не так. Даже очень хорошая структура еще не означает, что процесс будет идти автоматически. Чтобы система действительно работала, ей нужно понимать, что должно происходить при появлении нового проекта.
Если каждый раз автор вручную создает основной материал, потом отдельно добавляет короткие ролики, потом отдельно заводит публикации, потом отдельно расписывает задачи, то система остается только красивой схемой. Она не помогает экономить внимание. Она не берет на себя рутину. Она не умеет запускать процесс. А ведь именно к этому мы стремимся.
Нам нужна такая архитектура, в которой проект не просто существует, а запускаетцепочку действий. Иначе система будет зависеть только от памяти автора. А это уже не операционная система, а просто аккуратно оформленное хранилище.
Автоматизация начинается с архитектурыЗдесь особенно важно не перепутать порядок. Часто люди думают, что автоматизация начинается с кнопок, скриптов или плагинов. На самом деле все наоборот. Сначала должна быть архитектура. Только после этого можно автоматизировать создание объектов, публикаций и задач.
Если архитектура не определена, любая автоматизация будет создавать хаос быстрее и эффективнее. Если же архитектура ясна, тогда кнопка «создать новый проект» может сразу запускать правильную последовательность действий. Она может создавать основной объект, заполнять нужные поля, генерировать дочерние материалы, подготавливать публикации для разных площадок и связывать все это между собой.
---------------------------------------------------------------------------------------------------------------------------
Авторское наблюдение
Когда я начала смотреть на свою работу как на систему проектов, а не как на набор отдельных заметок, многое встало на свои места. Раньше казалось, что одна тема существует отдельно от другой, а каждая новая задача требует своего отдельного ручного решения. Но когда я увидела, что все это части одного процесса, стало намного легче думать не о файлах, а о логике движения контента.
Особенно сильно это ощущается в мультиплатформенной работе. Один и тот же материал редко заканчивается на публикации в одном месте. Обычно он порождает дополнительные форматы, создает служебные задачи и оставляет след в аналитике. Пока этот путь не зафиксирован, автору приходится удерживать его в голове. Когда же у проекта появляется архитектура, система начинает поддерживать этот путь сама.
В моей собственной системе основным контентом является видео. Именно оно становится центром проекта, вокруг которого постепенно появляются дополнительные материалы. Из одного видео могут родиться несколько коротких роликов, которые расширяют тему, добавляют юмор или помогают вынести отдельную мысль. Из сценария к видео может появиться большая статья для тех, кто предпочитает читать. А в процессе производства нередко возникают материалы для подписчиков, которые тоже становятся частью проекта.
В этой книге я буду описывать все подходы именно на этом примере. Это не означает, что такая система подходит только видеоблогерам. Наоборот, я сознательно показываю один понятный и живой сценарий, чтобы было легче увидеть общую архитектуру. У каждого автора может быть свой основной тип контента, но сама логика системы остается одинаковой: один главный объект порождает дополнительные материалы, публикации, задачи и аналитику.
---------------------------------------------------------------------------------------------------------------------------Правило операционной системы:
Проект должен автоматически порождать все связанные с ним объекты: основной контент, дочерние материалы, публикации, задачи и аналитику.
Это правило переводит нас от статической структуры к живому процессу. Если проект существует сам по себе, а все остальные элементы приходится создавать отдельно, система остается слишком тяжелой и зависимой от ручного труда. Если же проект способен запускать цепочку связанных объектов, тогда система начинает работать как настоящая операционная среда.
Это правило также помогает удерживать правильный порядок мышления. Сначала мы проектируем архитектуру. Потом на ее основе создаем шаблоны. Затем подключаем автоматизацию. И только после этого начинаем строить панели управления и рабочие представления. Когда этот порядок соблюден, каждый следующий шаг становится логичным продолжением предыдущего.
---------------------------------------------------------------------------------------------------------------------------Как должен выглядеть готовый проектГотовый проект в нашей системе не должен быть просто заметкой с заголовком. Он должен содержать все, что нужно для работы с ним как с живой единицей. У него должен быть основной контент, к которому можно вернуться. У него должны быть дочерние материалы, если они предусмотрены типом проекта. У него должны быть публикации для каждой нужной площадки. У него должны быть задачи, которые сопровождают производство. И у него должна быть возможность отражаться в аналитике.
Такой проект можно сравнить с рабочим контейнером, внутри которого уже собраны все необходимые элементы. Автор создает его один раз, а дальше система помогает поддерживать порядок внутри этого контейнера. Это сильно отличается от привычного способа работы, когда каждую новую деталь приходится заводить отдельно и помнить, как она связана с остальными. Именно такой проект мы и будем строить в дальнейшем. Не как разрозненный набор заметок, а как единую сущность, которая умеет порождать все необходимые части самой себя.
ПрактикаПопробуйте сейчас мысленно взять один реальный пример своей работы и посмотреть на него как на проект. Не как на отдельное видео, статью или конспект, а именно как на целую единицу работы, внутри которой есть основной контент и дополнительные элементы.
Сначала назовите сам проект. Потом определите, какой материал является в нем основным. После этого выпишите, какие дочерние материалы обычно возникают в процессе работы. Подумайте, какие публикации должны появиться на разных площадках, какие задачи обязательно нужно создать и где потом должен отражаться результат.
Не пытайтесь сразу придумывать техническую реализацию. Сейчас важно увидеть саму архитектуру. Если вы можете мысленно разложить один проект на основной контент, дочерние материалы, публикации и задачи, значит фундамент главы уже начал работать.
Проверьте себяПосле этой главы попробуйте ответить на несколько вопросов.
Понимаете ли вы, почему проект должен быть центром системы? Можете ли вы объяснить, какие объекты должен порождать проект? Удается ли вам увидеть разницу между отдельным материалом и проектом, внутри которого существует несколько связанных сущностей?
Если на эти вопросы трудно ответить сразу, не спешите двигаться дальше. Сейчас важно, чтобы архитектура не просто была прочитана, а действительно стала понятной.
Итоги главыВ этой главе мы собрали воедино все основные элементы, с которыми уже познакомились ранее. Мы увидели, что операционная система автора строится не вокруг случайных файлов, а вокруг проекта, который объединяет основной контент, дочерние материалы, публикации, задачи и аналитику.
Мы также поняли, что одних только объектов, метаданных и связей недостаточно. Для настоящей системы важно, чтобы проект не просто существовал, а запускал правильную цепочку связанных действий. Именно это делает систему живой и пригодной для мультиплатформенной работы.
И наконец, мы зафиксировали еще одно правило будущей операционной системы: проект должен автоматически порождать все связанные с ним объекты. Это правило станет ключевым переходом к следующему этапу книги, где мы начнем строить уже не только архитектуру, но и сам механизм ее реализации.
Что дальшеТеперь, когда архитектура системы спроектирована целиком, мы готовы перейти к следующему большому шагу. В следующей части мы начнем переводить эту архитектуру в рабочее пространство Obsidian: посмотрим, как подготовить хранилище, структуру и шаблоны так, чтобы они поддерживали эту модель проекта.
Прежде чем перейти дальше, еще раз посмотрите на проект как на центральную единицу системы. Именно он соединяет между собой основной контент, дополнительные материалы, публикации и задачи. И именно вокруг него в
Конец ознакомительного фрагмента.
Текст предоставлен ООО «Литрес».
Прочитайте эту книгу целиком, купив полную легальную версию на Литрес.
Безопасно оплатить книгу можно банковской картой Visa, MasterCard, Maestro, со счета мобильного телефона, с платежного терминала, в салоне МТС или Связной, через PayPal, WebMoney, Яндекс.Деньги, QIWI Кошелек, бонусными картами или другим удобным Вам способом.