<?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[Stories by Sven Wiegand on Medium]]></title>
        <description><![CDATA[Stories by Sven Wiegand on Medium]]></description>
        <link>https://medium.com/@sven.wiegand?source=rss-bd6d6cd08a9e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*bb8X4ta2bi41KLQz8peayA.jpeg</url>
            <title>Stories by Sven Wiegand on Medium</title>
            <link>https://medium.com/@sven.wiegand?source=rss-bd6d6cd08a9e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 15:40:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sven.wiegand/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Using docker for on-premises Installations and Updates]]></title>
            <link>https://medium.com/@sven.wiegand/using-docker-for-on-premises-installations-and-updates-3f78eda4235?source=rss-bd6d6cd08a9e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f78eda4235</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[on-premise]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Sven Wiegand]]></dc:creator>
            <pubDate>Tue, 27 Sep 2022 06:58:06 GMT</pubDate>
            <atom:updated>2022-09-27T06:58:06.189Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>How we’ve massively reduced our on-premises efforts and opened up capabilities for using microservices in an on-premises environment.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CObgmvUJcp2cenxMbzNOmw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@wocintechchat">Christina @ wocintechchat.com</a> on <a href="https://unsplash.com/">Unsplash</a></figcaption></figure><p>“On-premises, really?” you might ask. I know … these days, everyone is talking about SaaS only. And though orgavision was built as a SaaS company in the first place, we’ve also had customers right from the beginning in 2009, how wanted to run our software on their servers in their data center.</p><p>At least in Germany, on-premises is still a topic — and I guess this might be true for other EU countries. Here are some reasons, why companies prefer on-premises over SaaS:</p><ul><li>Hospitals and other companies in the medical environment are working with particularly sensitive data, which they do not want to store outside their own environment.</li><li>Some companies fear to get in trouble with EU’s general data protection regulation (GDPR) because it’s often unclear, which infrastructure provider a SaaS company is using under the hood.</li><li>Others would rather not get locked in to recurring costs of a SaaS solution or simply have a no cloud policy.</li></ul><h4>Where did we come from</h4><p>Due to our on-premises offer it was clear right from the beginning, that orgavision cannot be built upon AWS, Google Cloud or other services because everything we wanted to build also needed to be executable in the IT infrastructure of our on-premises customers. This decision is some kind of a double-edged sword: On the one hand, it costs time to care about infrastructure components which are available as managed don’t-care-services by all the big providers. But on the other hand, it ensures that our SaaS solution is fully GDPR-compliant which wouldn’t be the case, when running on AWS or solutions from other US providers — even when their servers are located in the EU.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YEQm_Lt0VXeA-u52LXqMFA.jpeg" /><figcaption>The components of our old on-premises setup — each component is manually installed</figcaption></figure><p>So, our on-premises installations were nearly identical to our SaaS environment, but with all components on one server and without all the redundancy and load balancing. To get a working on-premises installation, quite a few components needed to be installed on our customer’s system:</p><ul><li>two different JVM versions</li><li>a JBoss</li><li>a Tomcat</li><li>PostgreSQL</li><li>and some other small components.</li></ul><p>These are quite heavy components, and so an automatic installation process would have been a feat of strength. And though our SaaS environment setup was fully automated using Ansible from day one — we felt we didn’t have time for an automatic setup process in the early years when the first customers asked for an on-premises installation. So, our DevOps engineers created an installation instruction and used it to manually set up our customers’ systems.</p><p>Due to tiny gaps in the instructions and different Linux distributions and Windows Server versions, every setup was somewhat unique: Different paths here and there, different environment variables and so on.</p><p>As a result, we didn’t only waste a lot of time for the initial installations, but also for the updates of the environments, which were also done manually. In 2018, the number of on-premises customers grew to about 50, and we were wasting more and more time for installations and updates.</p><p>And there was another problem: We had some topics on our roadmap which we wanted to address by introducing further components like Keycloak and Kafka to our stack. We also wanted to implement upcoming features in the form of microservices or <a href="https://scs-architecture.org/">self-contained-systems</a>. All of this would have resulted in further components to be installed manually in the on-premises environment — a no-go.</p><p>It was time to solve this problem!</p><h4>Docker to the rescue</h4><p>One idea was to build packages for Linux’ package managers. But we would rather not rely on the package manager’s dependency resolution with unpredictable results based on the Linux distribution and version our customers were using.</p><p>Another idea was to use classical installation builders especially for Windows Servers, but that didn’t really sound like fun.</p><p>As we were starting to migrate our SaaS environment to docker swarm in 2018, we thought about whether it might be a solution to use docker also on our customer’s servers.</p><p>But there were quite some challenges:</p><ul><li>Though docker was well established in the SaaS scene already in 2018, IT admins in companies outside the SaaS business didn’t know anything about docker.</li><li>About two thirds of our on-premises customers were running our software on Windows Server machines.</li></ul><p>We decided to ignore the first issue for now and deal with the second one by providing a Linux and a Windows version. Here is what we’ve learned regarding docker on Windows:</p><ul><li>Using docker desktop, you can run Linux containers on Windows for development and testing purpose, but this is definitely not an environment for production use.</li><li>Starting with Windows Server 2016 Microsoft introduced a native container runtime. But it was buggy as hell and non-functional in several areas, so effectively you need at least Windows Server 2019.</li><li>The Windows Server container runtime only runs native Windows containers based on Windows base images. These container images are getting quite large and — worst of all: You nearly don’t get any ready to use containers, as it is the case in the Linux world, where plenty of open-source teams are providing production-ready container images for their tool on docker hub.</li></ul><p>I wish we would have decided to stick with Linux only, but that’s another story to be told …</p><h4>Automatic installs and updates using docker compose</h4><p>After a few months of work on wrapping our application components into docker containers, extending our CI to automatically build the containers and composing a container stack, we came up with our final solution.</p><p>An installation now is as simple as this:</p><ul><li>The customer downloads a ZIP archive from our customer area and unpacks it on his server.</li><li>The archive contains a docker-compose file specifying all the containers in their matching version, networks, volumes, and ports. The customer doesn’t need to care about this file and isn’t allowed to change anything here.</li><li>Additionally, the archive contains an .env-file listing several configuration variables which can be set to the customer&#39;s needs and are imported by the compose file.</li><li>After logging in to our private docker registry, a simple docker-compose up downloads all required images (if they are not already available on the system) and starts up the whole stack.</li></ul><p>The entire installation can be done in just a few minutes. And the best: An update in its easiest form just requires a restart of the docker-compose stack — the newest versions of the containers will be downloaded and the stack will be started.</p><h4>Defining responsibilities</h4><p>In an on-premises scenario, it is always important to clearly define the responsibilities and installation requirements.</p><p>In our case, our customer has to provide the (virtual) machine with the operating system, the docker runtime and docker compose (the versions required at least by our stack are documented). We provide the compose file, the configuration template and the container images for the full stack, even including a matching version of PostgreSQL.</p><p>Based on the experience from our first installations, we’ve started to implement our “on-premises check”: A simple container which performs checks on the customer’s system based on the exact same configuration file which will be used for running the final application. Here are some of the checks it performs:</p><ul><li>Is docker and docker compose installed correctly? Because the checker is a container on its own, it wouldn’t run at all otherwise.</li><li>Does the server’s hostname match the configured URL?</li><li>Are the provided certificates for HTTPS correct?</li><li>Is the configured mail server reachable?</li><li>Is the configured LDAP server reachable?</li></ul><p>Using this tool, the customer can verify that his system fulfills the requirements and that the configuration file matches his environment. Running the on-premises check before the installation is mandatory and has to be confirmed by the customer using a web form including the checkers output.</p><h4>Benefits for all of us</h4><p>After nearly two years, we’ve migrated our last on-premises customer from a classic manual installation to the docker-based installation in spring 2022.</p><p>Introducing the docker-based installation did cost us quite some efforts and required some propaganda work to convince our customers — where most of them haven’t heard of docker before — that the step of migrating their existing system is necessary.</p><p>For us, it was a giant step forward — not only in our on-premises business: We save dozens of person days on installations and updates each year, which we can now invest in improving our application. And we finally have the possibility to add additional components to our stack and outsource functionality into microservices or self-contained systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9HHoH0N6ssIBb8V6XkOSRA.jpeg" /><figcaption>The components of our docker-based on-premises setup. Less installation and update effort but more flexibility to introduce new things like a microservice for sending notification mails and introducing better search capabilities based on Elastic Search</figcaption></figure><p>But also our customers have plenty of benefits:</p><ul><li>The classic installation and update always needed to be performed by our engineers. Now the customer can decide whether he wants to install/update on his own or pay us for doing it. This not only saves them money, but gives them more flexibility.</li><li>The downtime for an update is only a few minutes now, where it was about 4 hours before.</li><li>As all the containers are continuously built and our customers can install updates on their own, they can operate on their own pace, respecting their needs.</li></ul><p>The effort we’ve spent was definitely well invested and already paid off!</p><p>One other thing we’ve learned is, that the container runtime on Windows Server is more of a problem than a solution. That’s why we’ve recently announced, that we will discontinue support for Windows by spring 2023 …</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f78eda4235" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Commands & Events instead of CRUD — Part 1: Commands]]></title>
            <link>https://medium.com/@sven.wiegand/commands-events-instead-of-crud-part-1-commands-17f4c7aee33b?source=rss-bd6d6cd08a9e------2</link>
            <guid isPermaLink="false">https://medium.com/p/17f4c7aee33b</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[crud]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[crud-commands]]></category>
            <category><![CDATA[cqrs]]></category>
            <dc:creator><![CDATA[Sven Wiegand]]></dc:creator>
            <pubDate>Thu, 13 Dec 2018 11:26:00 GMT</pubDate>
            <atom:updated>2022-10-06T05:32:56.583Z</atom:updated>
            <content:encoded><![CDATA[<h3>Commands &amp; Events instead of CRUD — Part 1: Commands</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PqrgwFVqxZ3HYPDxBBOnvA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/y_WDEY9e6mA?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Daniel Bradley</a> on <a href="https://unsplash.com/search/photos/order?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Countless applications — especially in the enterprise area — implement entity manipulation mainly based on the CRUD operations. CRUD is an acronym for</p><ul><li><strong>C</strong>reate</li><li><strong>R</strong>ead</li><li><strong>U</strong>pdate</li><li><strong>D</strong>elete</li></ul><p>These operations seem to fit the classical form-based entity operations: Somewhere in the UI you click an “Add”-button, a form allows you to capture data (like a new contact in a CRM system), you hit save and the new entity is created in the database.</p><p>When you want to edit an entity, nearly the same form is shown, but prefilled with the entity’s data from the database. You can modify the fields, hit “Save” and the modified entity is persisted.</p><h4>Typical Problems of CRUD</h4><p>From the implementation’s perspective in both situations (creation and update) an entity object of the same class is sent around. Even if the user only changes the phone number of a contact, the whole entity is updated in our database.</p><p>For rapid prototyping and very basic applications this might be a good approach as it allows a quick implementation. CRUD operations are natively supported by many frameworks. They can be easily implemented based on a relational database using abstraction layers like JPA or Hibernate and there are also tech stacks like Ruby on Rails or Grails which make implementing CRUD operations very fast.</p><p>But in most products business needs grow over time and — as you will see — CRUD is very limited in its capabilities . The following list isn’t complete, but it shows typical requirements and problems I’ve encountered multiple times in my developer life.</p><h4>Problem 1: Large Entity Classes with plenty of optional Properties</h4><p>Business objects which look simple at the beginning of a product’s lifecycle grow over time. Simply look at a contact object in a normal CRM application: What looks easy and small in the beginning becomes a monster class with dozens of properties over time spreading multiple tabs in a UI.</p><p>Often there are views which only show a subset of your monster entity object. What do you want to do with the irrelevant data here?</p><ul><li>Do you want to include <em>all</em> the data in the object sent to the UI?</li><li>Do you want to create new specialized data transfer objects?</li><li>Or do you want to use your standard entity object and leave the not-required fields unset (aka null)?</li></ul><p>This becomes even more interesting if you want to save the changes the user has made in the input form: Which fields do you want to transfer? Everything which is shown in the form or only what the user edited? And how should your low-level services know which fields they can expect to be set and which are okay to be left empty?</p><p>In most applications, I’ve seen a mix of slightly specialized objects and setting fields to null has been used. The developers wanted to avoid creating specialized objects for <em>all</em> use cases. Partly because there was no clear rule when to introduce new data transfer objects, and partly because they had no idea how to name these new classes.</p><p>As a result, over time, it becomes hard to update the service layer. There is no clear logic when which data transfer objects are used and which fields of the used objects can be expected to be set. This leads to tons of not-null-checks in null-safe languages, or more likely and even worse to many NullPointerExceptions.</p><h4>Problem 2: Implementing Undo</h4><p>In most products earlier or later, the wish for undoing changes is raised. Implementing this in a CRUD-based application is at least difficult.</p><h4>Problem 3: Providing a Change History</h4><p>A requirement which often arrives later in a product’s lifecycle is the possibility to provide a change history for important entities to answer the question of who did when change which properties of the entity?</p><p>Implementing this in a classical CRUD-application is possible, but complex.</p><h4>Problem 4: Implementing Collaboration</h4><p>Things really become challenging if you want to provide users the possibility to collaboratively work on objects. In most CRUD applications, the latest change overwrites previous changes made in parallel by other users.</p><p>I don’t know <em>how</em> often I had to deal with this issue in my life already. As a last resort, most teams implement some kind of locking to prevent parallel editing of business objects. But think of a tool like <a href="https://trello.com/">Trello</a> — a simple Kanban-board solution — and how useless it would be if you couldn’t collaborate with your colleagues on one card at the same time…</p><h4>Commands to the Rescue</h4><p>Think about how you would implement something like Trello using only entity objects and CRUD. You might say that Trello is an extreme example, as collaboration is at its core, but is it really? Think about the (enterprise?) application you are currently working on and about how cool it would be if it provided real collaboration, undo, …</p><p>So let&#39;s take a look at commands and how they can help us to make our app more appealing and our code clearer and less error-prone.</p><h4>Declaring Commands</h4><p>A command is an object that describes a <em>request</em> to do something and contains exactly the information required to perform an action of <em>one</em> specific type.</p><p>Commands and events are most fun in languages which provide syntax for one-line data classes, like for example Kotlin or Scala. So, let&#39;s take a look at how commands for working with cards on a Kanban board might look in Kotlin:</p><pre>// Commands.kt<br>typealias UserId = String<br><br>interface Command {  <br>  val user: UserId<br>}<br><br>// CardMessages.kt<br>typealias CardId = String<br>typealias ColumnId = String</pre><pre>data class CardPosition(val column: ColumnId, val before: CardId?)<br><br>sealed class CardCommand : Command {<br>  abstract val card: CardId<br>}<br><br>data class CreateCard(<br>  override val user: UserId, <br>  val board: BoardId, val pos: CardPosition, <br>  override val card: CardId, val title: String<br>) : CardCommand()<br><br>data class RenameCard(<br>  override val user: UserId, override val card: CardId, <br>  val currentTitle: String, val title: String<br>) : CardCommand()<br><br>data class MoveCard(<br>  override val user: UserId, override val card: CardId, <br>  val currentPos: CardPosition, val pos: CardPosition<br>) : CardCommand()<br><br>data class DeleteCard(<br>  override val user: UserId, override val card: CardId<br>) : CardCommand()</pre><p>You can ignore the Kotlin details here, like sealed classes and type declarations.</p><p>From the code above, you can derive some characteristics of commands:</p><ul><li>A command contains all information required to execute the requested operation.</li><li>A command contains all information required to validate the requested operation.</li><li>A command is a lightweight one-time immutable object. You create it when you need it and drop it afterwards.</li></ul><p>When working with commands created by the client, it is best to work with decentralized ID creation (UUIDs). This avoids problems like for example double creation of entities.</p><h4>Command Validation</h4><p>I can’t stress often enough, that commands are <em>requests</em> to do something. Thus, a command should contain all information required to validate whether the request is valid and can be processed. This is also a benefit compared to sending around entities: Entities contain only their data — data required for validation must be collected from somewhere else.</p><p>From the code above, you can see, for example, that we’ve included information about the user who submitted the command. This allows us to verify, if the user is allowed to execute this request or dismiss it otherwise.</p><p>You may wonder about the currentTitle property of the RenameCard command: This allows us to verify, that the client (GUI, app) who send the command is in sync. If the currentTitle does not match the card&#39;s real current title as known by the server, we might want to reject the request.</p><h4>Processing Commands</h4><p>Now let’s take a look at how to process commands. Assume that they are rooted to a central command receiver, which then forwards them based on their type to specialized receivers:</p><pre>// CommandReceiver.kt<br>...<br>fun receive(cmd: Command) = when (cmd) {<br>  is BoardCommand -&gt; boardCommandReceiver.receive(cmd)<br>  is ColumnCommand -&gt; columnCommandReceiver.receive(cmd)<br>  is CardCommand -&gt; cardCommandReceiver.receive(cmd)<br>  ...<br>  else -&gt; Unit<br>}<br>...</pre><p>The specialized command receiver implements our business logic. It validates the command and rejects it if necessary. If the validation is successful, it mutates our entity’s state:</p><pre>// CardCommandReceiver.kt<br>...<br>fun receive(cmd: CardCommand) = when (cmd) {<br>  is CreateCard -&gt; validateAndCreateCard(cmd)<br>  is RenameCard -&gt; validateAndRenameCard(cmd)<br>  is MoveCard -&gt; validateAndMoveCard(cmd)<br>  is DeleteCard -&gt; validateAndDeleteCard(cmd)<br>} <br><br>...<br><br>private fun validateRenameCard(cmd: RenameCard) {<br>  val user = getUser(cmd.user) // throws if user doesn&#39;t exist<br>  val card = getCard(cmd.card) // throws if card doesn&#39;t exist<br>  if (!user.canModify(card))<br>    throw NotAllowedException()<br>  if (card.title != card.currentTitle)<br>    throw IllegalStateException(&quot;Concurrent change&quot;)<br>  cardDao.renameCard(card.id, cmd.title)<br>}<br><br>...</pre><h4>Problems solved yet</h4><p>Let&#39;s check which of the above-mentioned problems we’ve solved until now.</p><p>We no longer deal with <strong>large entity objects</strong> with many optional fields. In the end, we can work with one card object representing our card for displaying it (more on this in the next part). As soon as we want to mutate our card, we don’t use the entity class at all. Instead, we send tiny, specialized, immutable command objects exactly describing our intent. For a single command, it is obvious to our service layer (our command receivers) which properties of the command can be expected to be not-null, reducing the number of NullPointerExceptions (and totally eliminating them as we use Kotlin here).</p><p>Regarding our second problem, we haven’t yet implemented <strong>undo</strong>, but it becomes as simple as that:</p><pre>fun undoCommandFor(cmd: CardCommand) = when(cmd) {<br>  is CreateCard -&gt; <br>    DeleteCommand(cmd.user, cmd.card)<br>  is RenameCard -&gt; <br>    RenameCard(cmd.user, cmd.card, cmd.title, cmd.currentTitle)<br>  is MoveCard -&gt; <br>    MoveCard(cmd.user, cmd.card, cmd.pos, cmd.currentPos)<br>  is DeleteCard -&gt; ...               <br>}</pre><p>See how easy it is to invert most of the commands to undo them. Just the DeleteCard-command isn&#39;t that easy, as you really would need to restore the whole object …</p><p>It would also be straightforward to implement a <strong>change history</strong> based on the successfully executed commands, but this will become even easier based on events, as you might see in the next post.</p><p>The same is true for <strong>collaboration</strong>: We’ve already made things <em>much</em> better here, as concurrent changes will no longer override each other. Instead of writing a whole object when editing its title, we <em>request</em> our service layer to just rename the title. If another user moves the card in the same moment, both changes will succeed independent of each other. If two users edited a card’s title, the first one would win and the request of the second user will fail with an IllegalStateException as the command&#39;s currentTitle parameter wouldn&#39;t be “valid” anymore.</p><p>But we still haven’t solved the collaboration topic fully: We need to find a way to send the status updates back to all clients. Commands are not perfect here, as they are <em>requests</em>, and we need to communicate <em>facts</em> to the clients instead. More on this in part 2 …</p><h4>New Problems created</h4><p>Commands are no silver bullet and create new problems on their own. One challenge is, finding the correct level of granularity. It’s obvious, that we cannot create unique command types to update each single property of an entity.</p><h4>Conclusion</h4><p>Thinking about commands is a great way of thinking about the use cases we want our application to support</p><p>Commands express fine-grained intends of what a user <em>wants</em> to change in our system. Instead of sending whole entity objects (or even worse: partial ones with lots of null-properties resulting in NullPointerExceptions) we send tailor-made one-shot objects exactly describing the user&#39;s request.</p><p>Our command receivers implement the business logic by validating the commands and applying them to our persisted data in case they are valid. The commands contain all information required for validation and execution. Thus, our code becomes obvious as processing commands always follows the same pattern.</p><p>Implementing undo functionality has become mostly trivial because generating inverted variants of commands is easy in most cases. And finally, commands provide a good foundation for implementing a change history and collaborative editing.</p><p>In the next part, we will take a look at events and learn how they are related to commands and how we can benefit from them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17f4c7aee33b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Personal Kanban Part 2 — Personal Kanban with Trello]]></title>
            <link>https://medium.com/hackernoon/personal-kanban-part-2-personal-kanban-with-trello-a6bd6cdb0588?source=rss-bd6d6cd08a9e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a6bd6cdb0588</guid>
            <category><![CDATA[trello]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[management]]></category>
            <category><![CDATA[personal-kanban]]></category>
            <category><![CDATA[kanban]]></category>
            <dc:creator><![CDATA[Sven Wiegand]]></dc:creator>
            <pubDate>Sat, 24 Nov 2018 20:12:19 GMT</pubDate>
            <atom:updated>2018-11-24T20:12:19.100Z</atom:updated>
            <content:encoded><![CDATA[<h3>Personal Kanban Part 2 — Personal Kanban with Trello</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qxTxqZlwBT_rdNHgJqmS_w.png" /><figcaption>Generated with MagicMockups</figcaption></figure><p>In <a href="https://hackernoon.com/personal-kanban-part-1-why-todo-lists-don-t-work-3b5c6dc78708">my first post</a> I showed you why Personal Kanban is the perfect task tracking solution for me. In a side note I suggested to use post-its on a whiteboard to bring Personal Kanban to live. But is this really what we want? Don‘t we want to take our tasks with us in our pocket without carrying a pen around? And in the end we are hackers — that‘s why we read this publication. And so it‘s only a natural step for us to look for a digital solution.</p><h4>Finding the right Tool</h4><p>There are quite a bunch of tools outside that claim to be Kanban solutions: <a href="https://trello.com/">Trello</a>, <a href="https://www.meistertask.com/">MeisterTask</a>, <a href="https://zenkit.com/">Zenkit</a> and <a href="https://www.atlassian.com/software/jira">JIRA</a> are just a few of them.</p><p>Before picking a tool you should consider these points:</p><ul><li>Is modifying the boards and columns easy? You might adjust the board to your growing needs from time to time. And this should be a matter of seconds rather minutes.</li><li>Is creating and editing cards easy? This is what you do permanently on a Kanban board. So it should not only be easy, but it should be really fun.</li><li>Decide for yourself whether you need card labels, checklists, due dates, attachments and comments and check whether the tool supports you here.</li><li>Are there unlimited archives available? See below what this is good for.</li><li>What about the filtering and searching capabilities?</li><li>Are there mobile apps available for your preferred platform and do the apps sync instantaneously? That’s crucial if you want to carry your board with you.</li><li>You are a developer, so keyboard shortcuts might be your thing — at least they are for me.</li><li>Does the tool feel snappy? You will really use it a lot, so it should be fun and don‘t stand in your way.</li></ul><p>From the above mentioned tools at least Trello ticks all the boxes. JIRA might look like a natural choice as many of you might already have it in your company, but it disqualifies itself as the application is too slow, creating cards feels to heavy and adjusting the board requires too much steps to feel lightweight (though this might change with <a href="https://www.atlassian.com/software/jira/whats-new">the new Jira</a>).</p><p>Trello served me well for the last four years. So the rest of this post will focus on using Trello to manage your tasks.</p><p>I‘ve also checked out <a href="https://www.meistertask.com/">MeisterTask</a> and <a href="https://zenkit.com/">Zenkit</a>, but there was always at least one bit missing like support for shortcuts or limited archiving capabilities.</p><p>Another issue is the pricing. A price of 10 bucks/user/month is okay if your company decides to choose the tool for the whole team. But for a tool I use on my own 120 bucks or more a year feels too much — especially as I prefer to pay tools for personal productivity on my own. Trello provides a middle course with their <a href="https://trello.com/gold">Trello Gold Plan</a> which provides larger card attachments (up to 250 MB instead) and up to three power-ups per board (see below).</p><p>Most of those companies would do themselves a favor if they would provide the full powered solution for up to three users or at least individuals for free or for a price similar to Trello’s Gold plan. Normally these people become the influencers who then introduce the payed solution for the whole team.</p><h4>Getting started</h4><p>I will <em>not</em> give you a step-by-step introduction for how to use Trello as it should be mostly self-explanatory — instead I’ll just point you into the right directions to help you to get the most out of it. Setting up your first personal Kanban board with the structure described in <a href="https://hackernoon.com/personal-kanban-part-1-why-todo-lists-don-t-work-3b5c6dc78708">my first post</a> should be a matter of seconds once you‘ve signed up for an account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lyA1rBdYY0Dh59La_XSeMw.png" /><figcaption>Personal Kanban Board in Trello with empty columns</figcaption></figure><p><strong>Tips:</strong></p><ul><li>You can drag and drop columns to rearrange them.</li><li>You can double click the space between two columns to insert a new one.</li></ul><h4>Creating Cards</h4><p>Once you have the columns set up you can start creating your first cards representing tasks. As you will notice it’s a breeze to create cards as you only need to type the title and hit enter. Afterwards you can immediately enter the next card.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7whMRLKMqu-8I9SzaN_mkA.png" /><figcaption>Our first cards</figcaption></figure><p>Click on the card to view its details. Here you can enter a description and edit all of its attributes.</p><p><strong>Tips:</strong></p><ul><li>You can create a bunch of cards in one step: Ensure that the titles of the cards you want to create are in your clipboard separated by line breaks (e.g. by copying them from an editor or from excel). Then simply paste it into a new card. As soon as you create it, Trello will create one card for each line.</li><li>Once you’ve created a card you can edit its title without opening it by focusing it and hitting e on your keyboard.</li><li>The description field and many other places in Trello like checklist items and comments support markdown syntax to format text.</li></ul><h4>Make it your own</h4><p>Now you have a board with columns and cards. That’s the core of Personal Kanban, but it looks a bit boring. So start to make the board yours.</p><p>At first you should set a background image that appeals you. You can do it from the menu which you can open with the according button on the right.</p><p><strong>Tips:</strong></p><ul><li>You can always toggle the menu with the w key.</li></ul><p>Next you should add labels to your cards. I use labels to put my cards into categories like “Staff”, “Research”, “Development” and so on. This helps me to quickly find a matching task for the right mood. I ensure to put at least one label on each card as this gives a more homogenous look and I assign my labels different colors to easily identify them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gqsoVMQZJuMwEFQpbuN0uQ.png" /><figcaption>Your final board might look like this</figcaption></figure><p>Besides simple categorization I also have special labels like for example the „Strategic“ label and I ensure to work at least on one of them per week. This helps me to ensure that I don’t get lost in daily work but also keep the „big thing“ running.</p><p><strong>Tips:</strong></p><ul><li>You can create, edit and delete labels from the board’s menu and also from the popup used to assign labels to a card.</li><li>By default only colored bars are shown on cards. In Trello’s web application you can click on one of them and the names will be shown permanently for all labels.</li><li>Before you create your own labels you should delete the existing ones as they mess up your list otherwise.</li><li>You can add labels to a card immediately when creating them by typing the # character when entering the title.</li><li>You can add and remove labels to and from a card without opening it by focusing it and hitting the l key.</li></ul><h4>Checklists</h4><p>One of my favorite Trello feature are checklists. You can create as many of them as you like on each card and each checklist can have as many checklist items as required.</p><p>For example if I create a card for writing a longer mail I use a checklist to capture the topics I need to cover in the mail.</p><p>I <em>love</em> checklists for complex recurring tasks like creating monthly reports or ending or starting a sprint. They help me to ensure that I don’t forget a thing of a complex process — exactly like a pilot uses his landing checklist to ensure that he pulls out the landing gear before dropping.</p><p>For recurring tasks the last item on my checklist is the reminder to copy the task to have a new instance for the next occurrence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ThuXkc9ZDbiBPdIWrtVqKA.png" /><figcaption>A card with checklists</figcaption></figure><p>Trello will display a small indicator on cards with checklists showing the total number and the number of checked items. The indicator turns green as soon as all items are checked.</p><h4>Due Dates</h4><p>Trello allows you to set due dates on tasks. As we no longer need these dates to control the visibility of tasks (like we did in checklists), we can instead use it to note <em>real</em> due dates. So I only set due dates on cards where there really is a date at which the task has to be finished. As a result most of my tasks do <em>not</em> have due dates.</p><p>Trello provides notifications for cards which are due in 24 hours, but that isn’t very helpful, so I ignore it. But what I like is that the due date on a card becomes yellow 24 hours before it expires and red after it has expired. This provides a neat visual indicator which helps to identify due things.</p><p>When you move a card with a due date to your „Done“-column you should tick the checkbox provided with the due date to mark the date green.</p><p><strong>Tips:</strong></p><ul><li>You can add/edit a card’s date by focusing it and hitting the d key.</li></ul><h4>Finding Stuff</h4><p>Trello provides two features to find cards:</p><ol><li>the board filter and</li><li>the global search.</li></ol><p>The board filter is a great tool if your board contains a lot of cards and you want to find a specific one. You can activate it in the board’s menu and it will allow you to filter for title and/or meta data and will immediately narrow down the board to only matching cards.</p><p>The global search box in Trello’s title bar in contrast searches over all your boards and even includes archived cards (see below). It provides special search syntax to narrow down the list of results.</p><p><strong>Tips:</strong></p><ul><li>You can quickly activate filtering mode using the f key.</li><li>You can clear an active filter using the x key.</li><li>You can focus the search box hitting / or ⇧+7 if you do not have a number block.</li></ul><h4>Documenting your Work</h4><p>What makes Trello <em>really</em> powerful and better than any physical Kanban board is its capability to keep all your information <em>forever</em>. That’s because normally you do not <em>delete</em> cards in Trello (though you can if you want) but you only <em>archive</em> them instead. Archived cards disappear from the board, but they are still there. So by the end of the week I do not delete tasks, but instead I choose the „Archive all cards“ action from the menu of the „Done“ column.</p><p>Why is this helpful in personal Kanban? Do you also know the situation that someone asks you about something you’ve handled two months ago and you can remember <em>that</em> you worked on it, but you cannot remember the <em>outcome</em> — the decisions you’ve made? I had this quiet often and it drove me crazy. But I no longer have this problem (mostly) since using Trello, because besides being my task organizing tool it is also my work log — my outsourced long-term memory.</p><p>But to make the archiving feature useful it is not enough to only have cards with titles, descriptions and meta data like dates. Things become really useful, if you also capture intermediate and final results on cards. To do this I use the comment feature. Though I’m working alone on my personal Kanban board I use comments really a lot.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MfTWPEkjdVkakWLwTOT84g.png" /><figcaption>A card’s history including comments</figcaption></figure><p>The following events are good triggers to add a comment to a card:</p><ul><li>When moving a card from the „In Progress“ column back to one of the scheduling columns it might be useful to comment why you’ve suspended the work.</li><li>When moving a card to the „Waiting“ column it makes sense to comment for what or whom it is waiting.</li><li>When resolving a card it may make sense to comment its outcome.</li></ul><p>How to access all this hidden knowledge when you need it? In the board’s menu in the „More“ section you’ll find the „Archived Elements“ action which shows you all archived elements and provides a search box. But I prefer to simply use the global search, as it not only searches active but also archived cards.</p><p>Opening an archived card provides you all the information you’ve capture there plus the information when you moved the card between columns, when the card has been archived and in which list it was when you archived it.</p><h4>More</h4><p>There is even more about using Trello for personal Kanban. Here are just some teasers:</p><ul><li>Trello supports a broad range of power-ups. Most of them add integration with other tools (like Slack or Zendesk), but others add useful internal features. You can use one power-up in a free account and up to three in the gold account.</li><li>My favorite power-up for personal Kanban is the „Card Repeater“. It allows you to set a repetition interval for a card. Once set, Trello will create a new instance of the card each time the interval has past.</li><li>Trello provides integration with <a href="https://ifttt.com/">IFTTT</a> which opens up interesting new possibility. Same like the support of the brand new Siri shortcuts in iOS 12.</li><li>Trello’s mobile apps are superb.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5YUb0Fb0RNgQvxGkunMbqA.png" /></figure><h4>Conclusion</h4><p>Trello makes my working live so much easier. It not only helps me to organize my work using <a href="https://hackernoon.com/personal-kanban-part-1-why-todo-lists-don-t-work-3b5c6dc78708">personal Kanban</a>, but it also helps me to <em>document</em> my work, so that I can easily dig out results from tasks which I’ve finished months ago. And all this works because using Trello is really fun. It feels lightweight, smooth and fast and I can do nearly everything using keyboard shortcuts.</p><p>You might think that I’m working for Trello or getting money from them for writing this, but this isn’t the case. It’s simply a tool I’m convinced of — call me a „Trello fanboy“.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a6bd6cdb0588" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/personal-kanban-part-2-personal-kanban-with-trello-a6bd6cdb0588">Personal Kanban Part 2 — Personal Kanban with Trello</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Personal Kanban Part 1 — Why Todo-Lists don‘t work]]></title>
            <link>https://medium.com/hackernoon/personal-kanban-part-1-why-todo-lists-don-t-work-3b5c6dc78708?source=rss-bd6d6cd08a9e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b5c6dc78708</guid>
            <category><![CDATA[management]]></category>
            <category><![CDATA[personal-kanban]]></category>
            <category><![CDATA[management-and-leadership]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[kanban]]></category>
            <dc:creator><![CDATA[Sven Wiegand]]></dc:creator>
            <pubDate>Mon, 03 Sep 2018 13:26:02 GMT</pubDate>
            <atom:updated>2020-08-15T07:35:44.635Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C3W25z9mqoEomu2s26p_RQ.png" /><figcaption>Photo by <a href="https://unsplash.com/photos/WC6MJ0kRzGw?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">David Travis</a> on <a href="https://unsplash.com/search/photos/post-it?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>As a CTO I have to handle dozens of tasks per week. Some of them are big, like digging into a new technology and others are tiny, like scanning through new candidate profiles or checking the latest bug reports. But all of these tasks <em>have</em> to be done. And to make things worse: Each conversation, each meeting and each mail can result in new tasks to be handled. So it’s crucial to have a task tracking system in place which works and ensures that I don‘t miss a thing and helps me to keep my deadlines.</p><p>Being a development manager for more than 12 years, I‘ve tried out several solutions until I finally found the one which served me well for the last four years.</p><p>In this first part I will tell you why todo lists do not work for me, but personal Kanban does. In the second part I will show how I use personal Kanban in practice and which tools I am using.</p><p>Be warned: Productivity methodology is a very personal thing — what might work great for me might be unproductive for you.</p><h4>Why Todo-Lists don‘t work</h4><p>There is probably no other domain, for which so many apps exist, like for todo lists. Hundreds — if not thousands — of products are courting for our favor. There are apps focusing solely on checklists like <a href="https://todoist.com/">todoist</a> and apps with other core domains which provide checklists as a supporting domain like <a href="http://outlook.office.com/">outlook</a>. But according to <em>my</em> experience most of them are not suited for more than tracking shopping lists.</p><h4>What to do <em>now</em>?</h4><p>Why do I think so? Well, checklists don’t provide me the right tools for focussing on what’s important at the moment… at least unless you plan <em>when</em> to do something in a very early stage — for example immediately when capturing a task.</p><p>To understand this statement we need to take a look at the tools typical apps provide us to narrow down our lists. Naturally I can stare at my complete list, but here we encounter the problem with not seeing the wood of the trees (while I write this I have 65 tasks on my list — not counting the several sub tasks). So as we don’t want to go through the whole list over and over again we need to filter the list. Most tools at least provide some predefined filters like</p><ul><li>„due today“ or</li><li>„due in the next 7 days“.</li></ul><p>Or you even get the possibility to create your own filters which opens up new capabilities depending on the meta data you can add to your tasks. Sounds good, doesn’t it? So what’s wrong here?</p><p>The problem is the due date: To make tasks appear in „due today“ I need to specify a due date for it. And as I do not want to go through all the tasks periodically I found myself adding a due date to a task immediately while creating it.</p><p>This is the total opposite of „agile“. In agile methodology a central principle is to delay decision to the latest possible point in time, simply because the more time passes, the more knowledge I gain to make a sustain decision.</p><p>As tasks are different in size, the due date is a bad indicator for when a task should appear on my radar. If I only need to make a phone call on a specific day it is totally okay if the task appears on the due date. But if I need to write a specification which might take me two weeks, it is too late if the task appears seven days upfront.</p><p>As a result I’ve found me setting „tactical“ due dates on <em>all</em> tasks. These were not the real dates until the tasks needed to be finished, but instead I specified when I wanted the task to appear in my filtered views. So in fact I’ve diverted the due date from its intended use and made it an „appear on my list date“.</p><h4>Surprise!</h4><p>Another side effect with the approach of the „appearance date“ is that tasks suddenly appear like Jack-in-the-box on your list. You thought you’re on track and looking forward to the weekend and then — boom — on Friday morning suddenly the monster specification You’ve scheduled half a year ago appears on your todo list.</p><p>This can be really distracting and demotivating. As a result, after a while it feels as if the todo list is <em>controlling</em> you instead of <em>supporting</em> you.</p><h4>Mostly done</h4><p>Checking todos is the reward we receive for our work. It simply feels good to tick off a task and see it disappear. I found myself often in the situation that I worked on a task for a whole day and it was nearly done, but a tiny feedback from someone else was required. In these situations I have different possibilities:</p><ul><li>Leave the task unchecked until I receive the feedback and ending my working day frustrated as it feels as I haven’t finished anything.</li><li>Tick off the task and create a new one to ask for the feedback. Well, this also doesn’t feel like progress.</li><li>Mark the task done to get the satisfaction for a hard day’s work and waiting for my colleague’s feedback which will then serve as my trigger to <em>really</em> finish the task. (Just lets hope that my colleague will not forget to send the feedback as the task will be stalled in nirvana then.)</li></ul><h4>TL;DR: Sum-up on Todo-Lists</h4><p>So after using todo lists for eight years, this is my conclusion on them:</p><p><strong>Pros:</strong></p><ul><li>They help me to get things out of my head.</li><li>They give me the good feeling that I wont miss a thing.</li></ul><p><strong>Cons:</strong></p><ul><li>To use filtered view I need to think about when it may be the best time to work on a task already when creating it.</li><li>Due dates are becoming tactical „appearance dates“ which is semantically wrong and takes away the possibility to specify a <em>real</em> due date if a task has one.</li><li>Tasks which have been captured long ago suddenly pop up like Jack-in-the-box in filtered views.</li><li>I tend to tick of tasks which are <em>mostly</em> (but not completely) done.</li></ul><h4>Personal Kanban to the Rescue</h4><p>So lets see what personal Kanban is and how it may help us. I could tell you why Taiichi Ohno invented and introduced Kanban in 1947 to optimize the production chain at Toyota and that Kanban has been adapted for the software industry in 2007 by David Anderson, but this would exceed this article‘s scope as personal Kanban is not <em>really</em> Kanban. The idea of personal Kanban has been developed by Jim Benson and Tonianne DeMaria Barry and has been published in 2011 in their book “Personal Kanban: Mapping Work | Navigating Life”.</p><h4>Visualizing State</h4><p>At its core Kanban is about visualizing state. The idea is: If I know the current state I can make profound decisions.</p><p>The visualization is based on three elements:</p><ol><li>A <strong>card</strong> represents a single task.</li><li>The <strong>Kanban board</strong> hosts all cards.</li><li>The board is separated into <strong>columns</strong> and each column represents a state a task can be in.</li></ol><p>The most left column indicates the initial state and the most right column the final state. So by default new cards are created in the left column and as the task progresses it is pulled across the board to the right.</p><h4>Our first Kanban Board</h4><p>Lets look at the simplest possible Kanban board:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*SaM1jIbnoCdpYQ-tvonDIw.png" /></figure><p>The columns have the following meanings:</p><ul><li><strong>Backlog:</strong> Our outstanding tasks</li><li><strong>In Progress:</strong> The tasks we are currently working on</li><li><strong>Done:</strong> Our finished tasks</li></ul><p>That looks pretty banal. But does even this simplest form of Kanban provide us a benefit about a simple task list? Yes, it already does:</p><ol><li>In our previously used checklist we could only distinguish between open and done tasks. Our Kanban board additionally lists the tasks we are currently working on.</li><li>The „Done“ column gives us an overview of what we’ve achieved. No more leaving the office and asking ourselves what we’ve done the whole day.</li></ol><p>Now you are already set: If you have a whiteboard and post-its you can immediately start. If you want to carry your „board“ with you, simply reserve a double page in your notebook and use tiny post-its.</p><h4>Blocked Tasks</h4><p>Lets go a step further. One of our problems with checklists was that we were not sure how to handle tasks for which our part is done but where we wait for contribution from others. So lets enhance our Kanban board with a new state <strong>Waiting</strong> to indicate exactly this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S8q_606ItVowjrhm1HFn_A.png" /></figure><p>If you’re done with your stuff and need things from your colleagues, simply pull the task in to the new column. This gives you the possibility to move something to the right — which feels like progress — but nevertheless you have a clear reminder that something is still pending and needs to be finished.</p><p>Whenever your „In Progress“ column runs empty you should at first take a look into your „Waiting“ column and check whether all of the tasks there are <em>really</em> still waiting for external contribution. If not prefer those over pulling new tasks from the „Backlog“ — better one task done than two in progress.</p><h4>Scheduling</h4><p>Our main concern with checklists is that they don‘t work well when it comes to scheduling tasks. Our current Kanban board doesn‘t provide any help here either: We only have a backlog column full of todos and need to scan through all of them each time we want to pick a new task.</p><p>To solve this issue lets add a new <strong>Today</strong> column to our board:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IdhvRMK18kf_I3MPx3OSxA.png" /></figure><p>Now each morning we can scan through our backlog column and pull into the „Today“ column those cards we plan to work on today. During the day we do not need to care about the full „Backlog“ column anymore and can solely concentrate on what we’ve planned for today.</p><p>To save us from scanning the full „Backlog“ column each morning we can further enhance our board:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*64K8refcaBHrdbZbfmPnaw.png" /></figure><p>Our final pull-workflow now looks like this:</p><ul><li><strong>Each morning</strong> you pull tasks from the „This Week“ into the „Today“ column.</li><li><strong>Each Monday</strong> you pull tasks from the „This Month“ into the „This Week“ column.</li><li><strong>Each 1st of a month</strong> you pull tasks from the „This Year“ into the „This Month“ column.</li><li><strong>Each 1st of January</strong> you pull tasks from the „Backlog“ into the „This Year“ column.</li><li><strong>Each Friday</strong> I empty my „Done“ column. This gives me a nice overview of what I’ve achieved this week.</li></ul><h4>Be creative</h4><p>Personal Kanban is all about you and your productivity. So adjust the board that it works best for you. Here are some ideas:</p><ul><li>If you have no regular monthly tasks you may prefer a „Next 4 Weeks“ column instead of the „This Month“ column.</li><li>If your „This Year“ and „Backlog“ columns are mostly empty, reject the year column.</li><li>When there are upcoming vacations I create a „Before Vacation“ column to the left of the „This Week“ column where I collect stuff that needs to be done before I leave.</li><li>Put a due date on the cards to indicate tasks which need to be finished on a specific date. This will help you when filling your scheduling columns.</li></ul><h4>Conclusion</h4><p>Personal Kanban is not for everyone as it requires you to regularly scan your board. So if you only have a handful of tasks to be tracked reminder tools might work better for you. But if you are like me and have to handle a lot of tasks each day, then personal Kanban might be for you. It provides you a handy tool for scheduling and tracking all your tasks. It helps you to keep focus on what’s important now and nevertheless you alway have all tasks in sight to avoid surprises. And as a bonus you get a nice overview of what you’ve achieved by simply looking into your „Done“ column.</p><p>In the next part I’ll show you, which tools I use to work with personal Kanban in practice and how these tools increase the benefits even more.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b5c6dc78708" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/personal-kanban-part-1-why-todo-lists-don-t-work-3b5c6dc78708">Personal Kanban Part 1 — Why Todo-Lists don‘t work</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>