Does Scheda fulfill its promise?

Introduction

Since it reached MVP maturity, I have been using Scheda exclusively for my note taking, gathering ideas and thoughts, and making sense of them. While gathering information (creating cards) was mostly smooth from the beginning (some limitations in the respective card editors aside), it became quickly evident that processing the information needed much more support.

It now reached a maturity where I consider it—for the time being—feature complete, in the sense that I haven't spotted any major gaps anymore and don't have anything on the list I would want it to be able to do. This will change rather sooner than later, I assume, as I use it, there sure will be features I would like to have that are not yet part of Scheda.

Requirements

In the first article I stated a list of requirements I want Scheda to fulfill. Let's go through them and take a critical look at each.

Always available without getting in my way

Requirement

Scheda cannot take over the screen, pull me out of my actual context when taking notes or looking them up. Taking a note has to be straightforward and hassle-free.

Evaluation

• Minimal screen footprint: the small file window per opened Scheda file, the individual card windows both make it sit comfortably on my desktop alongside whatever applications I am using;
• No need for filing etc. when creating a note, I don't even have to put a title to a card, I can just use Scheda like sticky notes to quickly gather some thoughts;
• Scheda is swift, no clunky, slow, cumbersome interface, smooth, adheres to the platform, and switching from an application to Scheda and back is barely noticeable;

I am running Scheda 24x7, without it ever getting in my way, but having it at my fingertips all the time really integrates it into my thinking. As a matter of fact, it already has significant influence: instead of keeping disparate notes or having to drop out of my thinking to deal with a note taking application that is more demanding, I use it much more than other applications I ever used, to the point of becoming kind of lazy: "Put a note in there and forget about it for the time being". When I feel like it, I can go over the collected material, notes not fleshed out are clearly marked with pending changes, search also allows me sorting by most recently added or changed.

Peace of mind

Requirement

I don't want to feel a constant fear in the back of my head that I might loose the information I stored in a Scheda file.

Evaluation

Scheda instantly stores every change, makes periodic backups, copies them to an external drive, and periodically checks the backups for integrity.

As said above, I run Scheda 24x7, never closing it (unless forced to because I added/changed code or an OS update requires a reboot), never have to safeguard the file or backups manually, never have to explicitly save a Scheda file.

I can also export information stored in Scheda as Markdown, thus even if I should stop using it, I can always take with me whatever I stored in it. In the same lines, I am not tied to a specific platform or OS, should I change my mind about them, I can take Scheda with me.

Even though I started using it as my daily driver before it was fully fleshed out, I never lost a single bit of information.

Future-proof

Requirement

It must always be possible to access my information, no matter how old or what version of Scheda it was written with.

Evaluation

Despite the rather stormy initial phase with many features added in a not necessarily organized and planned out way (using it was my driver, not a fully worked out plan and design specification), it still holds up this promise: no matter what Scheda file I open, old or new, information is always conserved.

Information stored in Scheda can always be exported to common "standard" formats, like Markdown (and from there via Pandoc to most everything), SVG, etc. Neither am I locked into a given platform, as long as Qt and SQLite are available (and some basic OS facilities), I can take Scheda with me.

Extensibility

Requirement

It must be reasonably simple to extend Scheda.

Evaluation

I started using Scheda when it had but (limited) text, file box, sketch and browser cards. Reference, search, and document cards were added only later, without causing any ripples through the code base: modules that could be written without having to touch the Scheda core, much less other card type implementations.

Functionality, like complex search queries, export formats, etc. could be added easily, too. Export formats required touching the different card type implementations, as only they know how their contents are to be represented or printed, but there is no way around this.

With the research/experimental approach some technical debt was incurred, the most significant one was printing and exporting: the different formats were added independently, leading to several independent code paths that duplicated functionality. A cleanup round was needed there, consolidating and refactoring the code. Not only for the sake of maintainability and code simplicity, but more importantly because the different paths did things slightly different, thus resulting in an inconsistent user experience, even if only minimal. Consolidating the code into ane path with hooked in special functionality to handle intrinsics of the different formats solved this and increased maintainability (and extensibility).

There is no public API or scripting provided with the current version of Scheda. I do plan on both, but until I gain more experience using it and seeing what would actually make sense (without, for example, potentially compromising data integrity), it is on ice. The main challenge will be finding a balance between end-user accessibility (simple enough for non-programmers) and programmers, who want to have more powerful interfaces.

Thought process support

Albeit not stated as a requirement originally, Scheda is obviously supposed to provide its main goal: support me in my thought process, be an extension to my brain.

So far, it holds up, the functionality it provides already helps me significantly, and it is a smooth extension of my processes, not a different context I have to switch into.

As of the presentation goals of Scheda's process support: All these articles about Scheda were written as cards in Scheda, assembled into documents then generated by Scheda, exported as Markdown and imported here, a straightforward "publishing" process that takes less than a minute. But most importantly, being able to work with cards, with small pieces of (self-contained) information is a godsend, made it orders of magnitude easier than having to work with an entire document, scrolling around, moving text, trying to keep things properly ordered.

Undoubtedly there will be more things I will discover and want, but so far extending Scheda's functionality has been reasonably straightforward, the main challenge was most of the time the GUI part, editors for cards, etc.—not the Scheda core, formats, or architecture.

Outlook

I finally made up my mind what scripting should look like to address non-programmers as well as programmers who want to do fancy stuff, and what functionality it should provide. It will be fenced in (safeguarded), no access to anything outside of Scheda (e.g. no network access) and provide mechanisms to undo whatever a running script changed. This is the next "big step" for Scheda.