Ultorg: The User Interface for Relational Databases
ultorg.com
ultorg.com
Mathias, if you are here and listening, I'm interested but $35 / month is the wrong price point for this. $420 for year.
I can buy DataGrip for $261 for three years and it has a perpetual fallback license that would let me pay for the first year and then stop and just not get updates.
IMO, to start, you want your product to be so good and so reasonably priced that it's easy for someone to decide to give it a try. You are coming in with a uber premium price and I think that's going to severely hinder your customer acquisition efforts.
Also, I almost never get a license to a tool like this where I'm not entitled to keep using it if I stop paying for it. There is just too much incentive on the part of the vendor to just keep driving the price up to the breaking point. With a fallback license like JetBrains has, if they get unreasonable about price, I can just exit.
Finally, in the age of LLMs, if this gets popular and the price point is wrong, someone is going to do a good job of producing a competitor and make it open source or much less expensive. Make the official version a reasonable enough price that there is no reason to not support you to make it better.
Just my $0.02 but hope it helps at some level.
Finally, I looked at the website and there was no way to contact you to tell you this personally. So...might want to fix that. Small org, easy contact should be part of the perk.
Agreed about the fallback. Paying monthly for a local tool with no fallback should give anyone pause.
---
I did kick the tires with a free trial; and would probably recommend this to anyone who needs to navigate a SQL database in a point-and-click manner.
However, I wouldn't be willing to try it under proprietary-software terms. Last week, I was thinking about eliciting open-source software with the Ultorg look and feel from an LLM, thus replicating Bakke's HCI research and enabling other HCI researchers to build on it, which won't be possible under a proprietary license.
My notes on Ultorg may be of interest; you can
git clone http://canonical.org/~kragen/sw/pavnotes2.git
The introduction:
> Eirik Bakke’s [SIEUFERD][0] (or, as he sometimes spells it, SIUEFERD) is a really interesting and promising generic database frontend, a “schema-independent database UI”. The elevator pitch is “a new kind of graphical query interface [with] the power of SQL but the ease-of-use of a spreadsheet”. (Unfortunately, he forgot to implement the DDL part of SQL, just doing the DML part.)
I can highly recommend Bakke's 5-minute talk on it from 10 years ago at https://vimeo.com/173726371.
Often, you are interested in nested results. "Give me all my customers with a list of their orders." However, when you do this with a join, you get a list of the orders with a copy of the customer information attached to each, instead. In Ultorg, you actually get the customer with a list of their orders nested in their row as a sub-table, but with that sub-table's headers cleverly floated to the top, so they're not repeated for each customer.
As a second trick, Ultorg manages to remember the relations, so the data is editable in the nested tables. (There are some limitations to this, I believe.)
I used the trial version of Ultorg at the beginning of the year (the example in the 2.1.4 changelog is based on my use case), and it was tons of fun to use. Ultorg is great. I wish I had discovered it right at the start of that small project.
Unfortunately, I do not have a regular use case for this, and for personal use and occasional unpaid hobby projects, Ultorg's license is not a good fit. So I check the website from time to time whether there's been a change to it; no luck so far.
I am no business expert, and I do not know how well Eirik is doing with the current model. However, I do have the impression that he underestimates how many people would have a use case in their private life for it, but not at $35/month. I think this could also help attract new commercial users. After all, it's much easier to convince your boss of purchasing a software if you have already built expertise by using it personally.
Alternatively, you might use functions to aggregate in the query, but they're not standard, as far I know, which means that interfaces in programming languages often do not support them. The best bet might be aggregating into JSON, but this removes quite a bit of the type information that values in SQL usually carry. (Also, the aggregation functions are generally less pleasant to write than standard joins.)
Because you don't need nested results. You can fire off another query.
Although I am venturing to guess that you feel you need nested queries because you're doing doing something stupid like trying to send SQL queries over the network where the cost of firing off another query becomes a great performance burden. But the answer to that is don't do that. SQL was specifically designed to be run on the same machine as your application.
If you need to present the data to network clients where nesting is necessary for performance reasons, turn your application into the network database service that produces nested data (the "API server" as the kids call it). Leave the SQL as an implementation detail hidden behind the scenes.
As I mentioned in the previous post, I am aware that this can be done with multiple queries and post-processing, but then I am implementing what essentially amounts to a join myself (of maybe I have something like an ORM do it for me). In any case, my data processing is now split up in two places.
And the point of Ultorg is that it provides an interface that does this post-processing into a nested representation. Except maybe for Gel (mentioned somewhere else here), I have not seen this in any other general interface for relational databases. If SQL supported nested results, this surely would be different.
It is a higher level concern so that isn't a bad thing. SQL is focused on giving you a view of your data. Whereas you want to combine many different views. That is where composing many different queries should be seen as quite natural at the interface point, not a shortcoming of SQL. If that composition isn't natural, you may want to take a closer look at your application's architecture.
> but then I am implementing what essentially amounts to a join myself
Joins and aggregated views are very different concepts. I think this misunderstanding, which is one I've seen many times before, stems from the hacks used to work around the aforementioned problems. Many have come to believe those hacks actually how SQL is designed to be used, not the hacks that they are.
> I have not seen this in any other general interface for relational databases.
Oracle has their thing. Its name escapes me at the moment. Postgres has json_agg/jsonb_agg and similarly SQL itself has array_agg. Lots of options out there.
But it's not only a question of if it can be done, but if it should be done. There are a lot of other advantages to moving query aggregation out into another application. There is a reason why we stopped sticking SQL servers directly in front of the clients and it isn't just because of SQL using a table representation.
Half the reason why ORMs have trouble has to do with the fact that you need to fetch has many relations via a second select.
Beyond that, it's the GPPL languages' fault that it doesn't support object or class fragments which are needed to support queries that return a subset of an object.
If people bothered fixing these two issues, then ORMs would be great.
It's a "new database" (actually a layer on top of Postgres). It has a more ergonomic query language, and it returns results as nested structures rather than rows. So "give me all my customers with a list of their orders" returns what you want.
Unfortunately, the startup that was developing Gel got acqui-hired, and Gel's future is unclear.
The second biggest flaw, which isn't really about SQL itself but in implementation, was attaching SQL to the network where latency starts to become a problem. That requires hacks to work around. This is likely this is why you're seeing data duplication — trading all that duplication to avoid the latency problems that wouldn't be a problem if you kept it on the same machine like SQL originally intended.
I had the same issue. I was enamored with the UI Ultorg presented for SQL. However once the pricing came out it felt.. harsh unless i was using a lot of SQL in my work, which i was not. If it was a Jetbrains style license i'd have one now, even though i rarely use DBs in this manner.
And I do agree with the criticisms mentioned in the thread. Ultorg is solving a lot of problems of data organisation and context awareness, so starting a business with a perpetual license would be awesome.
Guess I just don't wanna lose access to the tool once I have all the tailored files and fail to pay again.
Should mention that Eirik is a joy talk to and will quite possibly accommodate you. All the best to him.
You can kinda-sorta get similar navigation in LINQPad. (But that requires constructing queries using C# and using an ORM like Entity Framework, which may be beyond the technical capabilities of the target audience.)
I personally would prefer a web-based version instead of a desktop version.
It looks like a polished thing that from a UX perspective sits between a spreadsheet and PowerBI
It let's any user with DB access build reports pretty close to how you'd edit a spreadsheet and without having to build pipelines in PowerBI and setup ingestion etc, etc.
The closest thing I've seen here is the old Tableu Desktop, but this one is more focused on tables than figures.
Where is efficiency in UI if it has the same space wasting 0-filling design as everything else. At east in Excel you can mitigate some of it, but this app seems more auto,magical
> Dynamic Autolayout. To retain sanity, it is essential not to have to spend time tweaking formatting settings for each individual field, or for every new database query.
> Ultorg eliminates such hard, manual labor, by analyzing your data on the fly and deriving carefully tuned defaults.
2022 (255 points, 68 comments) https://news.ycombinator.com/item?id=31551328
Having published it so long ago means that it's excellent prior art for patents others might try to use against Ultorg or Ultorg clones.
These seem to be entirely different tools. Ultorg is a generic relational gui (like Bento, Access and so on), dbeaver is a database admin tool centered around writing SQL and managing tables.