All posts by user

Viewing your Kerika canvas like a regular Web page

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”:

Web page version of Canvas
Web page version of Canvas

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.

Help! Our designer is becoming a hipster…

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.

Beer from a mason jar
Beer from a mason jar

 

Kerika’s UI will probably change real soon. Expect it to get more hip.

Upgrading our server infrastructure

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.

Search for Retrieval, Exploration and Discovery

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:

  • “Where’s that contract that Arun signed last week?”
  • “Where’s the card where Arun and I discussed making changes to the contract?”
  • “Where’s the canvas where Arun laid out the product vision?”

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:

  • “Where are all the bugs we have fixed regarding this feature?”
  • “Where are all the contracts we have signed for this kind of work?”
  • “Who are all the people who have worked on search engine technology?”

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:

  • “Have any bugs every been reported for this feature?”
  • “Has anyone ever looked at this issue?”
  • “Is any work happening with this client?”

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…

 

 

 

Exporting just a subset of a Task Board or Scrum Board

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:

Exporting subset of board
Exporting subset of 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.

Kerika (not) in China

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…

Kerika makes FOIA one-click easy

If you work for a government agency in the United States – at the Federal, State, or Local level – you are subject to various public disclosure requirements, thanks to the Freedom of Information Act and various other federal and state “Sunshine” laws.

(And, if you work for a governmental organization anywhere in the European Union, that’s going to be true for you as well.)

Kerika makes it one-click easy for you to meet you disclosure requirements, thanks to the Archive and Export feature:

Archiving freezes a project, presumably in it’s “done” state: everyone who used to have access to the project still does, but all cards, canvases and documents associated with that project are made read-only.

This means that you now have a pretty good record for what a project looked like when it was completed: what work was done, by whom, and which documents were used and what conversations took place.

And the kind of integrated, comprehensive view of a done project is something that you can get only from Kerika: the old mix of SharePoint and Project and regular email just doesn’t work!

Exporting is the other piece of the disclosure puzzle: with just one mouse click, you can export all (or some) of the cards in a board, in CSV or HTML format.

Exporting in HTML is particularly helpful when meeting disclosure requests because the HTML output can be easily edited, using Microsoft Word for example, to take out items that need to be redacted for security or privacy reasons.

That’s the difference with a modern project management and team collaboration software like Kerika: the worst part of your government job just became one-click easy.

We have upgraded our SSL Security

We have upgraded the SSL certificate, used to secure your browser’s connection to kerika.com, from SHA-1 to SHA-2.

Kerika SSL
Kerika SSL

 

(SHA-2 is a cryptographic hashing algorithm developed by the National Institute of Standards and Technology (NIST) to replace SHA-1.)

This puts Kerika ahead of moves that Google and Microsoft will soon take, for the Chrome and Internet Explorer browsers, respectively, that will start showing warning signs when you visit a website that uses the older SHA-1 certificates.

If you are not sure whether your favorite secure site has upgraded to SHA-2, Symantec has a helpful tool you can use:

Kerika SSL check
Kerika SSL check

When Projects Get Done: Archive Them

Here’s another new feature with our latest update: when a project is done, you can drag it to the Archive column on your Home page.

Archiving Projects
Archiving Projects

Archiving a project freezes it: no one can make any changes to it while it is in the Archive, so if you change your mind and want to make some changes to an archived project, you need to drag it back out of the Archive and into your Projects column.

All the documents attached to an Archived Project are frozen: the goal here is to preserve the final/completed state of a project and all its assets, so that later on if you need to investigate a problem — or deal with a FOIA request or some other legal disclosure requirement — you can do so with confidence.

All dates, status, chat and teams are also frozen: if someone was part of an Archived Project’s team at the time the project was moved to the Archive, they will continue to show up on that project team.

If a task had a due date and hadn’t yet been completed (i.e. the card hadn’t yet been moved to the Done column), that due date stays intact.

If the project was a Scrum Board, it will continue to stay attached to the Backlog it was using at the time the board got archived: when you view an archived Scrum Board, it will show that Backlog in it’s current state.  This makes it easy to archive Scrum Boards that represent different Sprints that work off the same shared Backlog!

You can change your mind: If you need to work again on a previously archived project, just drag it out of the Archive column and drop it into the Projects column on your Home Page, and that will “un-archive” (restore) your project.

You can create templates from archived projects: if you drag an archived project and drop it into the Templates column on your Home Page, that will create a template based upon that project, while leaving the project in your Archive.