One of our users in Massachusetts alerted us to a bug in the export function that we have fixed with our latest release: it turns out the export function wasn’t correctly preserving the sort order of cards within the column, which was a nuisance.
Bug fixed, and as always, our thanks to our users for providing valuable feedback!
Here’s one of the weirder bugs we ever fixed: it turns out that there is a tiny grey dot in the middle of every canvas on a Whiteboard.
It’s been there for a while, ever since we introduced some animation to make it easier for people to understand that canvases can be embedded inside cards on Task Boards and Scrum Boards, as well as being used independently on Whiteboards.
But the funny thing is that none of our users, nor anyone on our team, noticed it because too many of us, it seems, eat in front of our computers all too often, so our screens are flecked with little bits of food debris most of the time :-)
One of our team members finally noticed it after assiduously cleaning his computer screen, and that’s how we discovered there was an HTML element there, with a zero size and absolute position at the center of the canvas (to help with the “exploding” animation effect when a canvas is opened).
Although this element has a height and width of zero, it also has a 1 pixel wide solid grey border, which is used in the animation.
And that’s what appeared as the tiny grey dot in the middle of the screen: one pixel of grey border, not any debris from our lunch.
The Tags filter button, which appears on the top-right corner of your Task Boards and Scrum Boards, lets you filter your view of a crowded board by showing just those cards that match a particular tag that you are using (or a particular color coding):
It used to be that when you were filtering your view of the board, you couldn’t add any new cards.
The reason made sense from a technical, geeky perspective, but it proved confusing and frustrating for our users, so we have added more flexibility by letting you add new cards even while you are using filtering.
The new cards will appear as you add them to the board, and stay there until you refresh your view of the board. At that point, whether the new cards continue to appear or not will depend upon whether they meet your tags filtering criteria or not.
That sounds complicated, we know, so let’s take a look at the original logic behind not letting users add cards while using tags filtering…
In the example screen shown above, the board has a bunch of tags defined, like admin, box, bug, canvas, and cleanup.
Suppose we were using filtering, to only show those cards that are tagged bug and box. With this filtering in effect, you are going to see only a small subset of all the cards that exist on the board — only those cards that have either bug or box as a tag. (Or both.)
So, what should happen if you add a new card to the board, which isn’t tagged bug or box?
From a strictly logical perspective, this new card shouldn’t be displayed, because it doesn’t match the filter criteria you are currently using — it should be displayed only if the new card had bug or box as one of its tags.
We originally dealt with this problem by saying that you couldn’t add new cards while using tags filtering, because the new cards would disappear immediately after you had added them, which we felt would make for a very confusing user experience.
(People would likely think they failed in their attempt to add a new card, and keep trying. Eventually they might turn off tags filtering, and then find they had added many copies of the same new card.)
So, that was one solution to the problem, but it still presented a user experience challenge because many folks would forget that they had turned on tags filtering, especially if they were bouncing around between multiple boards. (Yes, Barb, we are looking at you!)
If a user returned to a board and didn’t realize that they had tags filtering turned on, they would get confused as to why they were unable to add new cards.
We thought of a couple of different solutions to this problem, including the use of callouts (those balloon-like bubbles that appear to give you hints about how a page works) but we aren’t generally a fan of callouts — too many apps misuse them to excess these days.
So we have come up with what we think is a better solution: if you are using tags filtering, go ahead and add new cards. They will show up, but if you refresh your page, your tags filtering will be re-applied, and the new cards will be displayed only if they match the tags you want to show.
Did you know that any Kerika canvas, whether on a standalone Whiteboard or attached to a card on a Task Board or Scrum Board, can be viewed as a regular Web page by folks who have been given access to the board?
Kerika automatically creates a version of your canvas that can be viewed without the Kerika application: you can get this version by using the Project Info dialog, or, more simply, by just changing the “m” in the canvas’s URL to a “c”:
Every Kerika page has a URL of the form “https://kerika.com/m/…”
The URLs are randomly generated and unique: every card, every canvas, every board has a unique URL.
The first part of the URL is always of the form kerika.com/m/… There’s no special reason for using the “m”; it’s just part of Kerika’s history.
But if you change the “m” to a “c”, like in the example above where “https://kerika.com/m/SRXk” becomes “https://kerika.com/c/SRXk”, then you can view the Web page version of the canvas.
In the Web page version there are no buttons or other indications of the Kerika software: it looks and works just like a regular Web page.
Of course, security is not compromised: you cannot view the Web page version of a canvas if you aren’t permitted to access the Kerika canvas itself.
We are facing a small crisis over here at Kerika… Our designer has turned hipster. Apparently he has been drinking hand-crafted beer from a Mason jar while watching the sunset from the rooftop. It might have something to do with the temperature hitting 61 degrees Fahrenheit today, which pretty much qualifies as mid-summer in Seattle.
Kerika’s UI will probably change real soon. Expect it to get more hip.
We had problems occasionally with our servers running reliably, and if you were unlucky you may have noticed this.
Well, it took a very, very long time but we have finally figured out what’s happening.
It turns out that the garbage collection function on the Java Virtual Machine that runs our server software (all on a Linux virtual machine running on Amazon Web Service) was having problems: most of the time the garbage collection runs just fine on an incremental basis, taking up only a fraction of a second of CPU time, and periodically the JVM would do a full garbage collection as well.
The problem we are facing is that sometimes this full garbage collection would fail and immediately restart.
In the worst-case scenario, the garbage collection would start, fail and restart over and over again, until the server basically thrashed. And each time the full garbage collection ran, it took 5-7 seconds of CPU time (which is a really long time, btw).
We are trying to understand the best long-term solution for this, but in the short-term we can mitigate the problem in a variety of ways, including upgrading our server virtual machines to have more RAM.
One reason it took so long to debug is that we were chasing a red herring: we had noticed network spikes happening frequently, and we wrongly assumed these were correlated to the server’s CPU load spiking, but this turned out to be coincidental rather than causal.
Sorry about all this.
In response to a question posted on our YouTube channel, here’s a quick primer on how to color cards on Task Boards and Scrum Boards.
Open a card, and then hover over the card title with your mouse:
Clicking on the paintbrush button will bring up a color selection (and we will be adding to this soon!)
And that’s it!
We have been giving a lot of thought recently to how we can improve the Search function in Kerika, and in the process found ourselves thrashing between different design approaches — all of which seemed deficient in some respect.
To get a better grip on the problem we decided to put aside all of our designs and step back to think more deeply about the basic uses of Search.
We concluded that there are three trajectories of Search that we need to consider:
SEARCH FOR RETRIEVAL
When you are trying to find something you have seen before: an old card, an old project, and old chat message.
You know for sure that the item exists; you just don’t remember where you last saw it.
The goal for a Search function in this scenario is to minimize user frustration by reducing the number of clicks needed to find and retrieve it.
This assumes, of course, that the object that you are trying to retrieve does really exist: if its your memory that’s faulty, then the goal of the Search function must be to convincingly demonstrate that the target object doesn’t exist.
It’s easy to imagine examples of Search for Retrieval in the context of a Kerika user:
Search for Retrieval is not an important use on the Web, when you are using Google or Bing, because important items are more often bookmarked or scrapbooked for faster and more secure retrieval: if there is a Web page you need to return to often, you are going to rely upon your bookmarks more often than a new Google search.
But in a content management system like Kerika, which also integrates conversations, tasks, processes and people, Search for Retrieval is a critical use case.
SEARCH FOR EXPLORATION
Exploration differs from Retrieval in one fundamental way: the user wants to use something that exists as a starting point to discover other items that are related.
Exploration is about attacking a problem area from many different angles: you might not be certain what content exists that’s relevant, but you are certain that some relevant content does exist.
Examples of Exploration in Kerika might include:
For Exploration to succeed, we need to create moments of delight: if a user can easily find related information that they were really hoping does exist, then the experience of quickly finding this information is sheer delight — and delight is a completely different emotion than the absence of frustration.
Exploration is possible on the Web with Bing and Google: the search engines try to help you auto-complete your query, offer suggested searches, and try to cluster results by type: e.g. here are all the images that match you search, and here are all the videos that match your search.
SEARCH FOR DISCOVERY
Discovery is closer to Exploration than Retrieval, but different enough from both that we think it is worth considering as a separate search trajectory in it’s own right.
With Discovery, you are hoping to find something, but have no real certainty that anything exists.
This the crucial difference between Discovery and Exploration: with Exploration you are fairly certain something exists, but are not sure in what form the information exists, or where it can be found. With Discovery on the other hand, you are really venturing into unknown territory, with no assurance that anything might be found.
In the context of a Kerika user, Discovery might take the form of questions like:
With Discovery, we need to combine elements of both Retrieval and Exploration when considering the user interface: if no information exists, then how quickly can we let the user know that there is nothing to be found? In other words, how can we reduce frustration?
On the other hand, if something does exist that is worth discovering, how can we present the search results with good information scent?
CONCLUSION
It’s probably hard to support all three search trajectories equally well: we need to decide which search trajectories are most important in the current context of the user.
We could try to get clues from the user’s current view of Kerika — which project or page she is looking at, and which one she was looking at before — to try to guess which type of search trajectory she has in mind, but these guesses are not likely to be very accurate, and forcing the user to go down the wrong trajectory can be both frustrating and counter-productive.
We are still exploring these ideas, but look for a new Kerika Search in the coming weeks…
A tiny change in labeling in our latest version will, we hope, make it clear that Kerika’s Export feature is actually pretty smart about managing the amount of data that you export from a board:
What used to say “Export cards” now says “Export the cards shown”.
“Cards shown” means just what it says: if you are hiding some columns from view, or filtering your view of the board to show just those cards that match particular colors or tags, then only the cards currently shown are going to be exported.
This makes it really easy for you to manage what information goes into an export: if you don’t want the Backlog of a Scrum Board to be included, for example, just hide the Backlog from view before clicking on the Export button.
One of our users, normally resident in Poland, is in China right now on vacation, and found to his disappointment that he couldn’t login to his Kerika+Google account.
Actually, he couldn’t login to his Google Account at all.
This is disappointing to hear, but not entirely surprising: Google has had problems making its services available in China for a long time, and so Kerika+Google becomes collateral damage in this larger conflict…
The only long-term solution would be for Kerika to offer its own signup and file storage mechanism, which is something we have considered in the past but is not high on our priority list right now because we have some other stuff we want to build first that’s going to be simply amazing.
Which is good news or bad news, depending upon whether you are in China right now or not…