Task Management with Oinker: from the Simplest Form to Kanban

Task management is one of the areas where you can get the most out of Oinker. It’s more flexible than most task management applications and even allows you to generate knowledge directly from your tasks. It seamlessly connects task management and knowledge management.

In the simplest case of task management with Oinker, you just create two oink nodes such as “ToDo” and “Done” and move the tasks between them:

task1
When you move a task node to the “Done” node, don’t forget to drop it with the shift-key pressed, which means to “move the node“.

One of the important requirements in task management is an ability to change the priority of tasks anytime. With Oinker, you can easily change the order of tasks by drag-and-drop:

task2

If you are working with a team where there’s more than one assignee of tasks, adding “Doing (by someone)” nodes allows you to assign tasks to team members and track what’s going on in the project:

task3

You may want to add a validation phase by placing a “Validated” node, which allows the project manager or stakeholders to verify that each “Done” task produced the expected result:

task4

If this kind of task flow is driven by the validation, say, you can move a task from “ToDo” to “Doing” only when a “Done” task is validated or there are no waiting “Done” tasks (aiming to limit work-in-progress). It is called a “pull system” or “Kanban” method which gives you a way to get feedback and make problems visible as early as possible.

It’s quite simple and flexible, but you might think that it can be also done with a whiteboard and it’s more intuitive, as many of Kanban projects actually use it. That’s probably true. However, there are several merits to use a digital system, especially Oinker:

  • You can save all the completed tasks and search them later.
  • You can attach any additional information to a task and easily navigate it.
  • You can build your knowledge base with completed tasks and information attached to them.
  • You can collaborate with team members who work remotely.
  • You can create tasks directly from a chat.

 

Pursue the natural order in knowledge management

As David Allen wrote in Getting Things Done, we are living in the era where “Almost every project could be done better, and an infinite quantity of information is now available that could make that happen”. In this flood of information, we feel constant pressure from our knowledge work to organize everything in order not to drown in the chaos. For example, you may feel the urge to decompose your task into a work breakdown structure, or to outline your ideas in mind maps, etc.

There would be almost no knowledge workers who are skeptical of the value of practices like organizing complex information into a simple and comprehensive form. Besides the purpose of organizing, the urge of doing so can be explained in terms of the tendency of the human mind. The architect Christopher Alexander explained it in his essay A City is not a Tree as “because the mind’s first function is to reduce the ambiguity and overlap in a confusing situation and because, to this end, it is endowed with a basic intolerance for ambiguity – that structures like the city, which do require overlapping sets within them, are nevertheless persistently conceived as trees”.

As Alexander pointed out, when we organize something, it almost always means to arrange the things in a “tree” structure. That is partly because of our underlying tendency, but the tree is actually a powerful tool because it is easy to deal with and gives us a focus on important things.

However, while it simplifies the mental process, Alexander argued that “there is some essential ingredient missing from artificial cities (which are always organized to form a tree). When compared with ancient cities that have acquired the patina of life, our modern attempts to create cities artificially are, from a human point of view, entirely unsuccessful”.

His answer to fill the missing part of the tree is a more complex abstract structure called “semilattice”. To put it simply, the semilattice is a multi-parent structure while the tree is single-parent. In a tree as single-parent, any element can belong to only one context, which, Alexander argued, does not reflect the reality of natural cities.

tree-semilattice

As a knowledge organizing tool, Oinker adopted the semilattice as a data structure where you can put the same node into different parents:

connect-oink3

Although Alexander’s argument about the tree and semilattice is for urban design, I believe that the same can be said in knowledge management since both of these are artificial things.

If an issue can belong to only one topic, you can only understand it in terms of its single context. It is simple, but kind of being caged up in a single point of view. On the other hand, if the issue can belong to multiple topics, you can approach it from the various angles and even create a new context to explore another topic. This spontaneity is definitely important when you are brainstorming new ideas.

Of course, there would be worries about uncontrollable situations due to the complexity of the semilattice. However, in the rapidly changing situations we have to deal with, we probably have to look for a way to build the natural order in our knowledge management to adapt quickly to a new situation rather than simplifying everything into a rigid structure.

Markdown Support

Oinks are usually plain text with simple formatting (newlines, URL links and images, YouTube players), but you can also use Markdown syntax to add richer formatting.

markdown2

When an oink starts with “#md“, it enables Markdown formatting:

markdown1

Markdown cheatsheet

This is intended as a quick reference. For more complete info, see John Gruber’s original spec.

Headers

# Header1
## Header2
### Header3

Header1
=======

Header2
-------

headers

Emphasis

Emphasis, aka italics, with *asterisks* or _underscores_.

Strong emphasis, aka bold, with **asterisks** or __underscores__.

Combined emphasis with **asterisks and _underscores_**.

Strikethrough uses two tildes. ~~Scratch this.~~

emphasis

Lists

1. First ordered list item
2. Another item
  * Unordered sub-list. 
1. Actual numbers don't matter, just that it's a number
  1. Ordered sub-list
4. And another item.

lists

Links

[I'm an inline-style link](https://www.google.com)

[I'm an inline-style link with title](https://www.google.com "Google's Homepage")

links

Code

Inline `code` has `back-ticks around` it.

inline-code

To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab:

    This is a code block.

code-block1

Or just wrap your code in ``` and you won’t need to indent it by four spaces:

```
function test() {
  console.log("Markdown is a text-to-HTML conversion tool for web writers.");
}
```

code-block2

Tables

First Header  | Second Header
------------- | -------------
Content Cell  | Content Cell
Content Cell  | Content Cell

| First Header  | Second Header |
| ------------- | ------------- |
| Content Cell  | Content Cell  |
| Content Cell  | Content Cell  |

table1

Colons can be used to align columns.

| Tables        | Are           | Cool  |
| ------------- |:-------------:| -----:|
| col 3 is      | right-aligned | $1600 |
| col 2 is      | centered      |   $12 |
| zebra stripes | are neat      |    $1 |

table2

Blockquotes

> Blockquotes are very handy in email to emulate reply text.
> This line is part of the same quote.

Quote break.

> This is a very long line that will still be quoted properly when it wraps. Oh boy let's keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can *put* **Markdown** into a blockquote. 

blockquotes

Horizontal Rule

---

Hyphens

***

Asterisks

___

Underscores

hr

Connecting Oink Nodes

All of our knowledge consists of concepts that arose from experience or existing concepts. A concept is an essential unit of knowledge, but it cannot exist without relationships to other concepts as the concept of a “parent” cannot exist without a parent‐child relationship. Therefore you could say that knowledge is a set of relationships. When you come up with a new idea, it would boil down to the fact that you’ve just discovered a new connection. That’s why we think connecting oinks(posts in Oinker) is the most important feature in Oinker.

Connecting oinks is as simple as dragging and dropping. First you need to drag an oink from the timeline and drop it onto the board:

connect-oink1

As you can see, it will appear as a card, then you drop another oink onto it to create a new connection:

connect-oink2

The two oinks on the board look like copies or clones of the oinks in the timeline, but they are not exactly copies of the original ones. Let’s look at an interesting example:

connect-oink3

The oinks on the board are called “oink nodes”. The oink nodes made from the same oink or nodes with the same origin are a kind of cloned view to look at the original oink.

As you can see in the above movie, the default behavior of the drag-and-drop is to create a new oink node with the same origin (with the original node preserved). In some cases you may want to move a node (with the original node removed) and you can do that by dropping a node with shift-key pressed:

connect-oink4

Another useful shortcut is to post an oink with ctrl-key pressed, which allows you to directly append an oink node of the post to the selected node without the drag-and-drop:

connect-oink5

What is Oinker?

Online chat or instant messaging has become an essential way of communication in recent times. I would imagine that for many of you, it would be almost the primary channel to communicate with other people in your workplaces.

The messages in online chat are always flowing and older messages virtually disappear in terms of the concept of “stock and flow“. What would you do if there are decisions on the current project or seemingly important ideas flowing in your chat timeline? Actually, it happens all the time. You might copy and paste it into your project management system.

Oinker is the most powerful way to take advantage of these kind of opportunities. It looks like a plain chat program on the surface, but it allows you to save the specified messages (called ‘oinks’ in Oinker) on the spot, and more importantly, it allows you to connect the messages in an infinite number of ways to build sophisticated contents. In other words, it works as a bridge between stock and flow.

chatting

save-message

connect-messages

In an Oinker chatroom, the saved messages and organized contents are instantly shared with the roommates. You are not just chatting with the others but also elaborating ideas and contents collaboratively in real time.

Besides chatting, in terms of ideation, writing in small pieces promotes the output of your thoughts (as you may have experienced if you have ever used Twitter), therefore, Oinker is still useful even if you are chatting to yourself.