Quino Retrospective and Roadmap

Published by Marco on

Updated by Marco on

History

Before taking a look at the roadmap, let’s quickly recap how far we’ve come. An overview of the release schedule shows a steady accretion of features over the years, as driven by customer or project needs.

The list below includes more detail on the releases highlighted in the graphic.[1]

  • 0.1: Proof of concept with metadata, PostgreSql (data and schema-migration) and Winforms UI
  • 1.0: First customer product with PostgreSql, DevExpress Winforms UI and Reporting
  • 1.0.5: MS-SQL driver (parity with PostgreSql driver)
  • 1.5.0: Remoting data driver; require .NET 4.0
  • 1.6.0: Mongo/NoSQL data driver
  • 1.8.0: Rewrite data driver to use sessions
  • 1.8.5: Support improved metadata-generation pattern
  • 1.9.0: Add plugin/overlay support
  • 1.10.0: Require .NET 4.5; add JSON-based remoting protocol; Windows-service support
  • 1.13.0: Rewrite security API
  • v2.0-beta1: Rewrite configuration, logging and schema-migration APIs
  • v2.0-beta2: Add V2 generated-code format
  • 2.0: Finish configuration/IOC rewrite; produce NuGet packages for delivery
  • 2.2: Stabilize Winform; support aliased tables in queries
  • 3.0: Rewrite MetaBuilder API; improve support for plugins

We took 1.5 years to get to v1. The initial major version was to signify the first time that Quino-based code went into external production.[2]

After that, it took 6.5 years to get to v2. Although we added several large products that use Quino, we were always able to extend rather than significantly change anything in the core. The second major version was to signify sweeping changes made to address technical debt, to modernize certain components and to prepare for changes coming to the .NET platform.

It took just 5 months to get to v3 for two reasons:

  1. Although we were able to make a lot of planned changes in v2[3], we had to leave some breaking changes for future versions.[4]
  2. We now strictly adhere to the rule that a breaking change anywhere in the software’s API—and Quino’s API surface is large—leads automatically to a major-version change.[5]

Roadmap

So that’s where we’ve been. Where are we headed?

As you can see above, Quino is a very mature product that satisfies the needs of a wide array of software on all tiers. What more is there to add?

Quino’s design has always been driven by a combination of customer requirements and what we anticipated would be customer requirements.

We’re currently working on the following features.

Modeling improvements
This work builds on the API changes made to the MetaBuilder in v3. We’re creating a more fluent, modern and extensible API for building metadata. We hope to be able to add these changes incrementally without introducing any breaking changes.[6]
WPF / VSG

A natural use of the rich metadata in Quino is to generate user interfaces for business entities without have to hand-tool each form. From the POC onward, Quino has included support for generating UIs for .NET Winforms.

Winforms has been replaced on the Windows desktop with WPF and UWP. We’ve gotten quite far with being able to generate WPF applications from Quino metadata. The screenshots below come from a pre-alpha version of the Sandbox application included in the Quino solution.

 Sandbox Date Picker Sandbox Dialog View Sandbox Edit View Sandbox List View

You may have noticed the lovely style of the new UI.[7] We’re using a VSG designed for us by Ergosign, for whom we’ve done some implementation work in the past.

.NET Core

If you’ve been following Microsoft’s announcements, things are moving quickly in the .NET world. There are whole new platforms available, if you target your software to run on them. We’re investigating the next target platforms for Quino. Currently that means getting the core of Quino—Quino.Meta and its dependencies—to compile under .NET Core.

 Compiling Encodo.Core on the .NET Core PlatformAs you can see in the screenshot, we’ve got one of the toughest assemblies to compile—Encodo.Core. After that, we’ll try for running some tests under Linux or OS X. The long-term goal is to be able to run Quino-based application and web servers on non-Windows—and, most importantly, non-IIS—platforms.[8]

These changes will almost certainly cause builds using previous versions to break. Look for any additional platform support in an upcoming major-version release.


[1] There were, of course, more minor and patch releases throughout, but those didn’t introduce any major new functionality.
[2] Punchclock, our time-entry and invoicing software—and Quino “dogfood” product—had been in use internally at Encodo earlier than that.
[3] E.g. splitting the monolithic Encodo and Quino assemblies into dozens of new, smaller and much more focused assemblies. Reorganizing configuration around the IOC and rewriting application startup for more than just desktop applications was another sweeping change.
[4] One of those breaking changes was to the MetaBuilder, which started off as a helper class for assembling application metadata, but became a monolithic and unavoidable dependency, even in v2. In v3, we made the breaking changes to remove this component from its central role and will continue to replace its functionality with components that more targeted, flexible and customizable.
[5] In the years between v1 and v2, we used the minor-version number to indicate when breaking changes could be made. We also didn’t try as hard to avoid breaking changes by gracefully deprecating code. The new approach tries very hard to avoid breaking changes but accepts the consequences when it’s deemed necessary by the team.
[6] That is, when users upgrade to a version with the newer APIs, they will get obsolete warnings but their existing code will continue to build and run, as before the upgrade. In this way, customers can smoothly upgrade without breaking any builds.
[7] You may also have noticed that the “Sandbox Dialog View” includes a little tag in it for the “XAML Spy”, a tool that we use for WPF development. Just so you know the screenshots aren’t faked… :-)
[8] As with the WPF interface, we’re likely to dogfood all of these technologies with Punchclock, our time-tracking and invoicing system written with Quino. The application server and web components that run on Windows could be migrated to run on one of our many Linux machines instead.